diff --git a/crates/fayalite-proc-macros-impl/src/fold.rs b/crates/fayalite-proc-macros-impl/src/fold.rs index 22e7b82..49cc8c1 100644 --- a/crates/fayalite-proc-macros-impl/src/fold.rs +++ b/crates/fayalite-proc-macros-impl/src/fold.rs @@ -220,7 +220,6 @@ forward_fold!(syn::ExprArray => fold_expr_array); forward_fold!(syn::ExprCall => fold_expr_call); forward_fold!(syn::ExprIf => fold_expr_if); forward_fold!(syn::ExprMatch => fold_expr_match); -forward_fold!(syn::ExprMethodCall => fold_expr_method_call); forward_fold!(syn::ExprPath => fold_expr_path); forward_fold!(syn::ExprRepeat => fold_expr_repeat); forward_fold!(syn::ExprStruct => fold_expr_struct); diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs index 7441cb3..b0fe498 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs @@ -30,9 +30,7 @@ pub(crate) struct ParsedBundle { pub(crate) field_flips: Vec>>, pub(crate) mask_type_ident: Ident, pub(crate) mask_type_match_variant_ident: Ident, - pub(crate) mask_type_sim_value_ident: Ident, pub(crate) match_variant_ident: Ident, - pub(crate) sim_value_ident: Ident, pub(crate) builder_ident: Ident, pub(crate) mask_type_builder_ident: Ident, } @@ -127,9 +125,7 @@ impl ParsedBundle { field_flips, mask_type_ident: format_ident!("__{}__MaskType", ident), mask_type_match_variant_ident: format_ident!("__{}__MaskType__MatchVariant", ident), - mask_type_sim_value_ident: format_ident!("__{}__MaskType__SimValue", ident), match_variant_ident: format_ident!("__{}__MatchVariant", ident), - sim_value_ident: format_ident!("__{}__SimValue", ident), mask_type_builder_ident: format_ident!("__{}__MaskType__Builder", ident), builder_ident: format_ident!("__{}__Builder", ident), ident, @@ -431,9 +427,7 @@ impl ToTokens for ParsedBundle { field_flips, mask_type_ident, mask_type_match_variant_ident, - mask_type_sim_value_ident, match_variant_ident, - sim_value_ident, builder_ident, mask_type_builder_ident, } = self; @@ -529,7 +523,7 @@ impl ToTokens for ParsedBundle { semi_token: None, } .to_tokens(tokens); - let mut mask_type_match_variant_fields = mask_type_fields.clone(); + let mut mask_type_match_variant_fields = mask_type_fields; for Field { ty, .. } in &mut mask_type_match_variant_fields.named { *ty = parse_quote_spanned! {span=> ::fayalite::expr::Expr<#ty> @@ -571,58 +565,6 @@ impl ToTokens for ParsedBundle { semi_token: None, } .to_tokens(tokens); - let mut mask_type_sim_value_fields = mask_type_fields; - for Field { ty, .. } in &mut mask_type_sim_value_fields.named { - *ty = parse_quote_spanned! {span=> - ::fayalite::sim::value::SimValue<#ty> - }; - } - ItemStruct { - attrs: vec![ - parse_quote_spanned! {span=> - #[::fayalite::__std::prelude::v1::derive( - ::fayalite::__std::fmt::Debug, - ::fayalite::__std::clone::Clone, - )] - }, - parse_quote_spanned! {span=> - #[allow(non_camel_case_types, dead_code)] - }, - ], - vis: vis.clone(), - struct_token: *struct_token, - ident: mask_type_sim_value_ident.clone(), - generics: generics.into(), - fields: Fields::Named(mask_type_sim_value_fields), - semi_token: None, - } - .to_tokens(tokens); - let mut sim_value_fields = FieldsNamed::from(fields.clone()); - for Field { ty, .. } in &mut sim_value_fields.named { - *ty = parse_quote_spanned! {span=> - ::fayalite::sim::value::SimValue<#ty> - }; - } - ItemStruct { - attrs: vec![ - parse_quote_spanned! {span=> - #[::fayalite::__std::prelude::v1::derive( - ::fayalite::__std::fmt::Debug, - ::fayalite::__std::clone::Clone, - )] - }, - parse_quote_spanned! {span=> - #[allow(non_camel_case_types, dead_code)] - }, - ], - vis: vis.clone(), - struct_token: *struct_token, - ident: sim_value_ident.clone(), - generics: generics.into(), - fields: Fields::Named(sim_value_fields), - semi_token: None, - } - .to_tokens(tokens); let this_token = Ident::new("__this", span); let fields_token = Ident::new("__fields", span); let self_token = Token![self](span); @@ -673,31 +615,6 @@ impl ToTokens for ParsedBundle { } }, )); - let sim_value_from_bits_fields = Vec::from_iter(fields.named().into_iter().map(|field| { - let ident: &Ident = field.ident().as_ref().unwrap(); - quote_spanned! {span=> - #ident: v.field_from_bits(), - } - })); - let sim_value_clone_from_bits_fields = - Vec::from_iter(fields.named().into_iter().map(|field| { - let ident: &Ident = field.ident().as_ref().unwrap(); - quote_spanned! {span=> - v.field_clone_from_bits(&mut value.#ident); - } - })); - let sim_value_to_bits_fields = Vec::from_iter(fields.named().into_iter().map(|field| { - let ident: &Ident = field.ident().as_ref().unwrap(); - quote_spanned! {span=> - v.field_to_bits(&value.#ident); - } - })); - let to_sim_value_fields = Vec::from_iter(fields.named().into_iter().map(|field| { - let ident: &Ident = field.ident().as_ref().unwrap(); - quote_spanned! {span=> - #ident: ::fayalite::sim::value::SimValue::ty(&self.#ident), - } - })); let fields_len = fields.named().into_iter().len(); quote_spanned! {span=> #[automatically_derived] @@ -706,7 +623,6 @@ impl ToTokens for ParsedBundle { { type BaseType = ::fayalite::bundle::Bundle; type MaskType = #mask_type_ident #type_generics; - type SimValue = #mask_type_sim_value_ident #type_generics; type MatchVariant = #mask_type_match_variant_ident #type_generics; type MatchActiveScope = (); type MatchVariantAndInactiveScope = ::fayalite::ty::MatchVariantWithoutScope< @@ -744,34 +660,6 @@ impl ToTokens for ParsedBundle { fn source_location() -> ::fayalite::source_location::SourceLocation { ::fayalite::source_location::SourceLocation::caller() } - fn sim_value_from_bits( - &self, - bits: &::fayalite::bitvec::slice::BitSlice, - ) -> ::SimValue { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueFromBits::new(*self, bits); - #mask_type_sim_value_ident { - #(#sim_value_from_bits_fields)* - } - } - fn sim_value_clone_from_bits( - &self, - value: &mut ::SimValue, - bits: &::fayalite::bitvec::slice::BitSlice, - ) { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueFromBits::new(*self, bits); - #(#sim_value_clone_from_bits_fields)* - } - fn sim_value_to_bits( - &self, - value: &::SimValue, - bits: &mut ::fayalite::bitvec::slice::BitSlice, - ) { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueToBits::new(*self, bits); - #(#sim_value_to_bits_fields)* - } } #[automatically_derived] impl #impl_generics ::fayalite::bundle::BundleType for #mask_type_ident #type_generics @@ -803,57 +691,11 @@ impl ToTokens for ParsedBundle { } } #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::ToSimValue for #mask_type_sim_value_ident #type_generics - #where_clause - { - type Type = #mask_type_ident #type_generics; - - fn to_sim_value( - &self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - let ty = #mask_type_ident { - #(#to_sim_value_fields)* - }; - ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) - } - fn into_sim_value( - self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - let ty = #mask_type_ident { - #(#to_sim_value_fields)* - }; - ::fayalite::sim::value::SimValue::from_value(ty, self) - } - } - #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#mask_type_ident #type_generics> - for #mask_type_sim_value_ident #type_generics - #where_clause - { - fn to_sim_value_with_type( - &self, - ty: #mask_type_ident #type_generics, - ) -> ::fayalite::sim::value::SimValue<#mask_type_ident #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) - } - fn into_sim_value_with_type( - self, - ty: #mask_type_ident #type_generics, - ) -> ::fayalite::sim::value::SimValue<#mask_type_ident #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, self) - } - } - #[automatically_derived] impl #impl_generics ::fayalite::ty::Type for #target #type_generics #where_clause { type BaseType = ::fayalite::bundle::Bundle; type MaskType = #mask_type_ident #type_generics; - type SimValue = #sim_value_ident #type_generics; type MatchVariant = #match_variant_ident #type_generics; type MatchActiveScope = (); type MatchVariantAndInactiveScope = ::fayalite::ty::MatchVariantWithoutScope< @@ -893,34 +735,6 @@ impl ToTokens for ParsedBundle { fn source_location() -> ::fayalite::source_location::SourceLocation { ::fayalite::source_location::SourceLocation::caller() } - fn sim_value_from_bits( - &self, - bits: &::fayalite::bitvec::slice::BitSlice, - ) -> ::SimValue { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueFromBits::new(*self, bits); - #sim_value_ident { - #(#sim_value_from_bits_fields)* - } - } - fn sim_value_clone_from_bits( - &self, - value: &mut ::SimValue, - bits: &::fayalite::bitvec::slice::BitSlice, - ) { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueFromBits::new(*self, bits); - #(#sim_value_clone_from_bits_fields)* - } - fn sim_value_to_bits( - &self, - value: &::SimValue, - bits: &mut ::fayalite::bitvec::slice::BitSlice, - ) { - #![allow(unused_mut, unused_variables)] - let mut v = ::fayalite::bundle::BundleSimValueToBits::new(*self, bits); - #(#sim_value_to_bits_fields)* - } } #[automatically_derived] impl #impl_generics ::fayalite::bundle::BundleType for #target #type_generics @@ -951,81 +765,26 @@ impl ToTokens for ParsedBundle { ::fayalite::intern::Interned::into_inner(::fayalite::intern::Intern::intern_sized(__retval)) } } - #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::ToSimValue for #sim_value_ident #type_generics - #where_clause - { - type Type = #target #type_generics; - - fn to_sim_value( - &self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - let ty = #target { - #(#to_sim_value_fields)* - }; - ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) - } - fn into_sim_value( - self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - let ty = #target { - #(#to_sim_value_fields)* - }; - ::fayalite::sim::value::SimValue::from_value(ty, self) - } - } - #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics> - for #sim_value_ident #type_generics - #where_clause - { - fn to_sim_value_with_type( - &self, - ty: #target #type_generics, - ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) - } - fn into_sim_value_with_type( - self, - ty: #target #type_generics, - ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, self) - } - } } .to_tokens(tokens); if let Some((cmp_eq,)) = cmp_eq { - let mut expr_where_clause = + let mut where_clause = Generics::from(generics) .where_clause .unwrap_or_else(|| syn::WhereClause { where_token: Token![where](span), predicates: Punctuated::new(), }); - let mut sim_value_where_clause = expr_where_clause.clone(); - let mut fields_sim_value_eq = vec![]; let mut fields_cmp_eq = vec![]; let mut fields_cmp_ne = vec![]; for field in fields.named() { let field_ident = field.ident(); let field_ty = field.ty(); - expr_where_clause + where_clause .predicates .push(parse_quote_spanned! {cmp_eq.span=> #field_ty: ::fayalite::expr::ops::ExprPartialEq<#field_ty> }); - sim_value_where_clause - .predicates - .push(parse_quote_spanned! {cmp_eq.span=> - #field_ty: ::fayalite::sim::value::SimValuePartialEq<#field_ty> - }); - fields_sim_value_eq.push(quote_spanned! {span=> - ::fayalite::sim::value::SimValuePartialEq::sim_value_eq(&__lhs.#field_ident, &__rhs.#field_ident) - }); fields_cmp_eq.push(quote_spanned! {span=> ::fayalite::expr::ops::ExprPartialEq::cmp_eq(__lhs.#field_ident, __rhs.#field_ident) }); @@ -1033,13 +792,9 @@ impl ToTokens for ParsedBundle { ::fayalite::expr::ops::ExprPartialEq::cmp_ne(__lhs.#field_ident, __rhs.#field_ident) }); } - let sim_value_eq_body; let cmp_eq_body; let cmp_ne_body; if fields_len == 0 { - sim_value_eq_body = quote_spanned! {span=> - true - }; cmp_eq_body = quote_spanned! {span=> ::fayalite::expr::ToExpr::to_expr(&true) }; @@ -1047,9 +802,6 @@ impl ToTokens for ParsedBundle { ::fayalite::expr::ToExpr::to_expr(&false) }; } else { - sim_value_eq_body = quote_spanned! {span=> - #(#fields_sim_value_eq)&&* - }; cmp_eq_body = quote_spanned! {span=> #(#fields_cmp_eq)&* }; @@ -1060,7 +812,7 @@ impl ToTokens for ParsedBundle { quote_spanned! {span=> #[automatically_derived] impl #impl_generics ::fayalite::expr::ops::ExprPartialEq for #target #type_generics - #expr_where_clause + #where_clause { fn cmp_eq( __lhs: ::fayalite::expr::Expr, @@ -1075,17 +827,6 @@ impl ToTokens for ParsedBundle { #cmp_ne_body } } - #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::SimValuePartialEq for #target #type_generics - #sim_value_where_clause - { - fn sim_value_eq( - __lhs: &::fayalite::sim::value::SimValue, - __rhs: &::fayalite::sim::value::SimValue, - ) -> bool { - #sim_value_eq_body - } - } } .to_tokens(tokens); } @@ -1124,14 +865,6 @@ impl ToTokens for ParsedBundle { } })); quote_spanned! {span=> - #[automatically_derived] - impl #static_impl_generics ::fayalite::__std::default::Default for #mask_type_ident #static_type_generics - #static_where_clause - { - fn default() -> Self { - ::TYPE - } - } #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #mask_type_ident #static_type_generics #static_where_clause @@ -1154,15 +887,6 @@ impl ToTokens for ParsedBundle { }; } #[automatically_derived] - impl #static_impl_generics ::fayalite::__std::default::Default - for #target #static_type_generics - #static_where_clause - { - fn default() -> Self { - ::TYPE - } - } - #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #target #static_type_generics #static_where_clause { diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index e072135..9174566 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -129,9 +129,6 @@ pub(crate) struct ParsedEnum { pub(crate) brace_token: Brace, pub(crate) variants: Punctuated, pub(crate) match_variant_ident: Ident, - pub(crate) sim_value_ident: Ident, - pub(crate) sim_builder_ident: Ident, - pub(crate) sim_builder_ty_field_ident: Ident, } impl ParsedEnum { @@ -193,9 +190,6 @@ impl ParsedEnum { brace_token, variants, match_variant_ident: format_ident!("__{}__MatchVariant", ident), - sim_value_ident: format_ident!("__{}__SimValue", ident), - sim_builder_ident: format_ident!("__{}__SimBuilder", ident), - sim_builder_ty_field_ident: format_ident!("__ty", span = ident.span()), ident, }) } @@ -213,9 +207,6 @@ impl ToTokens for ParsedEnum { brace_token, variants, match_variant_ident, - sim_value_ident, - sim_builder_ident, - sim_builder_ty_field_ident, } = self; let span = ident.span(); let ItemOptions { @@ -418,133 +409,6 @@ impl ToTokens for ParsedEnum { )), } .to_tokens(tokens); - let mut struct_attrs = attrs.clone(); - struct_attrs.push(parse_quote_spanned! {span=> - #[allow(dead_code, non_camel_case_types)] - }); - ItemStruct { - attrs: struct_attrs, - vis: vis.clone(), - struct_token: Token![struct](enum_token.span), - ident: sim_builder_ident.clone(), - generics: generics.into(), - fields: FieldsNamed { - brace_token: *brace_token, - named: Punctuated::from_iter([Field { - attrs: vec![], - vis: Visibility::Inherited, - mutability: FieldMutability::None, - ident: Some(sim_builder_ty_field_ident.clone()), - colon_token: Some(Token![:](span)), - ty: parse_quote_spanned! {span=> - #target #type_generics - }, - }]), - } - .into(), - semi_token: None, - } - .to_tokens(tokens); - let mut enum_attrs = attrs.clone(); - enum_attrs.push(parse_quote_spanned! {span=> - #[::fayalite::__std::prelude::v1::derive( - ::fayalite::__std::fmt::Debug, - ::fayalite::__std::clone::Clone, - )] - }); - enum_attrs.push(parse_quote_spanned! {span=> - #[allow(dead_code, non_camel_case_types)] - }); - let sim_value_has_unknown_variant = !variants.len().is_power_of_two(); - let sim_value_unknown_variant_name = sim_value_has_unknown_variant.then(|| { - let mut name = String::new(); - let unknown = "Unknown"; - loop { - let orig_len = name.len(); - name.push_str(unknown); - if variants.iter().all(|v| v.ident != name) { - break Ident::new(&name, span); - } - name.truncate(orig_len); - name.push('_'); - } - }); - let sim_value_unknown_variant = - sim_value_unknown_variant_name - .as_ref() - .map(|unknown_variant_name| { - Pair::End(parse_quote_spanned! {span=> - #unknown_variant_name(::fayalite::enum_::UnknownVariantSimValue) - }) - }); - ItemEnum { - attrs: enum_attrs, - vis: vis.clone(), - enum_token: *enum_token, - ident: sim_value_ident.clone(), - generics: generics.into(), - brace_token: *brace_token, - variants: Punctuated::from_iter( - variants - .pairs() - .map_pair_value_ref( - |ParsedVariant { - attrs, - options: _, - ident, - field, - }| Variant { - attrs: attrs.clone(), - ident: ident.clone(), - fields: match field { - Some(ParsedVariantField { - paren_token, - attrs, - options: _, - ty, - comma_token, - }) => Fields::Unnamed(FieldsUnnamed { - paren_token: *paren_token, - unnamed: Punctuated::from_iter([ - Pair::new( - Field { - attrs: attrs.clone(), - vis: Visibility::Inherited, - mutability: FieldMutability::None, - ident: None, - colon_token: None, - ty: parse_quote_spanned! {span=> - ::fayalite::sim::value::SimValue<#ty> - }, - }, - Some(comma_token.unwrap_or(Token![,](ident.span()))), - ), - Pair::new( - Field { - attrs: vec![], - vis: Visibility::Inherited, - mutability: FieldMutability::None, - ident: None, - colon_token: None, - ty: parse_quote_spanned! {span=> - ::fayalite::enum_::EnumPaddingSimValue - }, - }, - None, - ), - ]), - }), - None => Fields::Unnamed(parse_quote_spanned! {span=> - (::fayalite::enum_::EnumPaddingSimValue) - }), - }, - discriminant: None, - }, - ) - .chain(sim_value_unknown_variant), - ), - } - .to_tokens(tokens); let self_token = Token![self](span); for (index, ParsedVariant { ident, field, .. }) in variants.iter().enumerate() { if let Some(ParsedVariantField { ty, .. }) = field { @@ -571,25 +435,6 @@ impl ToTokens for ParsedEnum { ) } } - #[automatically_derived] - impl #impl_generics #sim_builder_ident #type_generics - #where_clause - { - #[allow(non_snake_case, dead_code)] - #vis fn #ident<__V: ::fayalite::sim::value::ToSimValueWithType<#ty>>( - #self_token, - v: __V, - ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - let v = ::fayalite::sim::value::ToSimValueWithType::into_sim_value_with_type( - v, - #self_token.#sim_builder_ty_field_ident.#ident, - ); - ::fayalite::sim::value::SimValue::from_value( - #self_token.#sim_builder_ty_field_ident, - #sim_value_ident::#ident(v, ::fayalite::enum_::EnumPaddingSimValue::new()), - ) - } - } } } else { quote_spanned! {span=> @@ -608,18 +453,6 @@ impl ToTokens for ParsedEnum { ) } } - #[automatically_derived] - impl #impl_generics #sim_builder_ident #type_generics - #where_clause - { - #[allow(non_snake_case, dead_code)] - #vis fn #ident(#self_token) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - ::fayalite::sim::value::SimValue::from_value( - #self_token.#sim_builder_ty_field_ident, - #sim_value_ident::#ident(::fayalite::enum_::EnumPaddingSimValue::new()), - ) - } - } } } .to_tokens(tokens); @@ -701,142 +534,6 @@ impl ToTokens for ParsedEnum { } }, )); - let sim_value_from_bits_unknown_match_arm = if let Some(sim_value_unknown_variant_name) = - &sim_value_unknown_variant_name - { - quote_spanned! {span=> - _ => #sim_value_ident::#sim_value_unknown_variant_name(v.unknown_variant_from_bits()), - } - } else { - quote_spanned! {span=> - _ => ::fayalite::__std::unreachable!(), - } - }; - let sim_value_from_bits_match_arms = Vec::from_iter( - variants - .iter() - .enumerate() - .map( - |( - index, - ParsedVariant { - attrs: _, - options: _, - ident, - field, - }, - )| { - if let Some(_) = field { - quote_spanned! {span=> - #index => { - let (field, padding) = v.variant_with_field_from_bits(); - #sim_value_ident::#ident(field, padding) - } - } - } else { - quote_spanned! {span=> - #index => #sim_value_ident::#ident( - v.variant_no_field_from_bits(), - ), - } - } - }, - ) - .chain([sim_value_from_bits_unknown_match_arm]), - ); - let sim_value_clone_from_bits_unknown_match_arm = - if let Some(sim_value_unknown_variant_name) = &sim_value_unknown_variant_name { - quote_spanned! {span=> - _ => if let #sim_value_ident::#sim_value_unknown_variant_name(value) = value { - v.unknown_variant_clone_from_bits(value); - } else { - *value = #sim_value_ident::#sim_value_unknown_variant_name( - v.unknown_variant_from_bits(), - ); - }, - } - } else { - quote_spanned! {span=> - _ => ::fayalite::__std::unreachable!(), - } - }; - let sim_value_clone_from_bits_match_arms = Vec::from_iter( - variants - .iter() - .enumerate() - .map( - |( - index, - ParsedVariant { - attrs: _, - options: _, - ident, - field, - }, - )| { - if let Some(_) = field { - quote_spanned! {span=> - #index => if let #sim_value_ident::#ident(field, padding) = value { - v.variant_with_field_clone_from_bits(field, padding); - } else { - let (field, padding) = v.variant_with_field_from_bits(); - *value = #sim_value_ident::#ident(field, padding); - }, - } - } else { - quote_spanned! {span=> - #index => if let #sim_value_ident::#ident(padding) = value { - v.variant_no_field_clone_from_bits(padding); - } else { - *value = #sim_value_ident::#ident( - v.variant_no_field_from_bits(), - ); - }, - } - } - }, - ) - .chain([sim_value_clone_from_bits_unknown_match_arm]), - ); - let sim_value_to_bits_match_arms = Vec::from_iter( - variants - .iter() - .enumerate() - .map( - |( - index, - ParsedVariant { - attrs: _, - options: _, - ident, - field, - }, - )| { - if let Some(_) = field { - quote_spanned! {span=> - #sim_value_ident::#ident(field, padding) => { - v.variant_with_field_to_bits(#index, field, padding); - } - } - } else { - quote_spanned! {span=> - #sim_value_ident::#ident(padding) => { - v.variant_no_field_to_bits(#index, padding); - } - } - } - }, - ) - .chain(sim_value_unknown_variant_name.as_ref().map( - |sim_value_unknown_variant_name| { - quote_spanned! {span=> - #sim_value_ident::#sim_value_unknown_variant_name(value) => { - v.unknown_variant_to_bits(value); - } - } - }, - )), - ); let variants_len = variants.len(); quote_spanned! {span=> #[automatically_derived] @@ -845,7 +542,6 @@ impl ToTokens for ParsedEnum { { type BaseType = ::fayalite::enum_::Enum; type MaskType = ::fayalite::int::Bool; - type SimValue = #sim_value_ident #type_generics; type MatchVariant = #match_variant_ident #type_generics; type MatchActiveScope = ::fayalite::module::Scope; type MatchVariantAndInactiveScope = ::fayalite::enum_::EnumMatchVariantAndInactiveScope; @@ -878,41 +574,11 @@ impl ToTokens for ParsedEnum { fn source_location() -> ::fayalite::source_location::SourceLocation { ::fayalite::source_location::SourceLocation::caller() } - fn sim_value_from_bits( - &self, - bits: &::fayalite::bitvec::slice::BitSlice, - ) -> ::SimValue { - let v = ::fayalite::enum_::EnumSimValueFromBits::new(*self, bits); - match v.discriminant() { - #(#sim_value_from_bits_match_arms)* - } - } - fn sim_value_clone_from_bits( - &self, - value: &mut ::SimValue, - bits: &::fayalite::bitvec::slice::BitSlice, - ) { - let v = ::fayalite::enum_::EnumSimValueFromBits::new(*self, bits); - match v.discriminant() { - #(#sim_value_clone_from_bits_match_arms)* - } - } - fn sim_value_to_bits( - &self, - value: &::SimValue, - bits: &mut ::fayalite::bitvec::slice::BitSlice, - ) { - let v = ::fayalite::enum_::EnumSimValueToBits::new(*self, bits); - match value { - #(#sim_value_to_bits_match_arms)* - } - } } #[automatically_derived] impl #impl_generics ::fayalite::enum_::EnumType for #target #type_generics #where_clause { - type SimBuilder = #sim_builder_ident #type_generics; fn match_activate_scope( v: ::MatchVariantAndInactiveScope, ) -> (::MatchVariant, ::MatchActiveScope) { @@ -931,33 +597,6 @@ impl ToTokens for ParsedEnum { ][..]) } } - #[automatically_derived] - impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics> - for #sim_value_ident #type_generics - #where_clause - { - fn to_sim_value_with_type( - &self, - ty: #target #type_generics, - ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) - } - fn into_sim_value_with_type( - self, - ty: #target #type_generics, - ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { - ::fayalite::sim::value::SimValue::from_value(ty, self) - } - } - #[automatically_derived] - impl #impl_generics ::fayalite::__std::convert::From<#target #type_generics> - for #sim_builder_ident #type_generics - #where_clause - { - fn from(#sim_builder_ty_field_ident: #target #type_generics) -> Self { - Self { #sim_builder_ty_field_ident } - } - } } .to_tokens(tokens); if let (None, MaybeParsed::Parsed(generics)) = (no_static, &self.generics) { @@ -995,15 +634,6 @@ impl ToTokens for ParsedEnum { } })); quote_spanned! {span=> - #[automatically_derived] - impl #static_impl_generics ::fayalite::__std::default::Default - for #target #static_type_generics - #static_where_clause - { - fn default() -> Self { - ::TYPE - } - } #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #target #static_type_generics @@ -1022,34 +652,6 @@ impl ToTokens for ParsedEnum { const MASK_TYPE_PROPERTIES: ::fayalite::ty::TypeProperties = <::fayalite::int::Bool as ::fayalite::ty::StaticType>::TYPE_PROPERTIES; } - #[automatically_derived] - impl #static_impl_generics ::fayalite::sim::value::ToSimValue - for #sim_value_ident #static_type_generics - #static_where_clause - { - type Type = #target #static_type_generics; - - fn to_sim_value( - &self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - ::fayalite::sim::value::SimValue::from_value( - ::fayalite::ty::StaticType::TYPE, - ::fayalite::__std::clone::Clone::clone(self), - ) - } - fn into_sim_value( - self, - ) -> ::fayalite::sim::value::SimValue< - ::Type, - > { - ::fayalite::sim::value::SimValue::from_value( - ::fayalite::ty::StaticType::TYPE, - self, - ) - } - } } .to_tokens(tokens); } diff --git a/crates/fayalite-proc-macros-impl/src/lib.rs b/crates/fayalite-proc-macros-impl/src/lib.rs index 4f7c4f0..5fe3ae8 100644 --- a/crates/fayalite-proc-macros-impl/src/lib.rs +++ b/crates/fayalite-proc-macros-impl/src/lib.rs @@ -93,7 +93,6 @@ mod kw { custom_keyword!(output); custom_keyword!(reg_builder); custom_keyword!(reset); - custom_keyword!(sim); custom_keyword!(skip); custom_keyword!(target); custom_keyword!(wire); diff --git a/crates/fayalite-proc-macros-impl/src/module.rs b/crates/fayalite-proc-macros-impl/src/module.rs index 62b7837..0852f58 100644 --- a/crates/fayalite-proc-macros-impl/src/module.rs +++ b/crates/fayalite-proc-macros-impl/src/module.rs @@ -377,7 +377,7 @@ impl ModuleFn { module_kind, vis, sig, - mut block, + block, struct_generics, the_struct, } = match self.0 { @@ -439,12 +439,6 @@ impl ModuleFn { body_sig .inputs .insert(0, parse_quote! { m: &::fayalite::module::ModuleBuilder }); - block.stmts.insert( - 0, - parse_quote! { - let _ = m; - }, - ); let body_fn = ItemFn { attrs: vec![], vis: Visibility::Inherited, diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs index a0f8eb0..c67f8dc 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs @@ -16,7 +16,7 @@ use std::{borrow::Borrow, convert::Infallible}; use syn::{ fold::{fold_expr, fold_expr_lit, fold_expr_unary, fold_local, fold_stmt, Fold}, parenthesized, - parse::{Parse, ParseStream}, + parse::{Nothing, Parse, ParseStream}, parse_quote, parse_quote_spanned, spanned::Spanned, token::Paren, @@ -27,13 +27,6 @@ use syn::{ mod expand_aggregate_literals; mod expand_match; -options! { - #[options = ExprOptions] - pub(crate) enum ExprOption { - Sim(sim), - } -} - options! { pub(crate) enum LetFnKind { Input(input), @@ -959,7 +952,7 @@ with_debug_clone_and_fold! { #[allow(dead_code)] pub(crate) struct HdlLet { pub(crate) attrs: Vec, - pub(crate) hdl_attr: HdlAttr, + pub(crate) hdl_attr: HdlAttr, pub(crate) let_token: Token![let], pub(crate) mut_token: Option, pub(crate) name: Ident, @@ -1180,7 +1173,7 @@ impl Visitor<'_> { Some(_) => {} } } - fn process_hdl_if(&mut self, hdl_attr: HdlAttr, expr_if: ExprIf) -> Expr { + fn process_hdl_if(&mut self, hdl_attr: HdlAttr, expr_if: ExprIf) -> Expr { let ExprIf { attrs, if_token, @@ -1188,10 +1181,10 @@ impl Visitor<'_> { then_branch, else_branch, } = expr_if; - let (else_token, else_expr) = else_branch.unzip(); - let else_expr = else_expr.map(|else_expr| match *else_expr { - Expr::If(expr_if) => Box::new(self.process_hdl_if(hdl_attr.clone(), expr_if)), - _ => else_expr, + self.require_normal_module_or_fn(if_token); + let else_expr = else_branch.unzip().1.map(|else_expr| match *else_expr { + Expr::If(expr_if) => self.process_hdl_if(hdl_attr.clone(), expr_if), + expr => expr, }); if let Expr::Let(ExprLet { attrs: let_attrs, @@ -1213,19 +1206,7 @@ impl Visitor<'_> { }, ); } - let ExprOptions { sim } = hdl_attr.body; - if sim.is_some() { - ExprIf { - attrs, - if_token, - cond: parse_quote_spanned! {if_token.span=> - *::fayalite::sim::value::SimValue::<::fayalite::int::Bool>::value(&::fayalite::sim::value::ToSimValue::into_sim_value(#cond)) - }, - then_branch, - else_branch: else_token.zip(else_expr), - } - .into() - } else if let Some(else_expr) = else_expr { + if let Some(else_expr) = else_expr { parse_quote_spanned! {if_token.span=> #(#attrs)* { @@ -1687,8 +1668,6 @@ impl Fold for Visitor<'_> { Repeat => process_hdl_repeat, Struct => process_hdl_struct, Tuple => process_hdl_tuple, - MethodCall => process_hdl_method_call, - Call => process_hdl_call, } } } @@ -1696,7 +1675,7 @@ impl Fold for Visitor<'_> { fn fold_local(&mut self, mut let_stmt: Local) -> Local { match self .errors - .ok(HdlAttr::::parse_and_leave_attr( + .ok(HdlAttr::::parse_and_leave_attr( &let_stmt.attrs, )) { None => return empty_let(), @@ -1715,11 +1694,10 @@ impl Fold for Visitor<'_> { subpat: None, }) = pat else { - let hdl_attr = - HdlAttr::::parse_and_take_attr(&mut let_stmt.attrs) - .ok() - .flatten() - .expect("already checked above"); + let hdl_attr = HdlAttr::::parse_and_take_attr(&mut let_stmt.attrs) + .ok() + .flatten() + .expect("already checked above"); let let_stmt = fold_local(self, let_stmt); return self.process_hdl_let_pat(hdl_attr, let_stmt); }; diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs index 61f6c75..b5a0ad3 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs @@ -1,103 +1,45 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information - -use crate::{ - kw, - module::transform_body::{ - expand_match::{parse_enum_path, EnumPath}, - ExprOptions, Visitor, - }, - HdlAttr, -}; +use crate::{kw, module::transform_body::Visitor, HdlAttr}; use quote::{format_ident, quote_spanned}; -use std::mem; use syn::{ - parse_quote_spanned, punctuated::Punctuated, spanned::Spanned, token::Paren, Expr, ExprArray, - ExprCall, ExprGroup, ExprMethodCall, ExprParen, ExprPath, ExprRepeat, ExprStruct, ExprTuple, - FieldValue, Token, TypePath, + parse::Nothing, parse_quote, parse_quote_spanned, spanned::Spanned, Expr, ExprArray, ExprPath, + ExprRepeat, ExprStruct, ExprTuple, FieldValue, TypePath, }; impl Visitor<'_> { pub(crate) fn process_hdl_array( &mut self, - hdl_attr: HdlAttr, + hdl_attr: HdlAttr, mut expr_array: ExprArray, ) -> Expr { - let ExprOptions { sim } = hdl_attr.body; - let span = hdl_attr.kw.span; - if sim.is_some() { - for elem in &mut expr_array.elems { - *elem = parse_quote_spanned! {elem.span()=> - ::fayalite::sim::value::ToSimValue::to_sim_value(&(#elem)) - }; - } - parse_quote_spanned! {span=> - ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_array) - } - } else { - for elem in &mut expr_array.elems { - *elem = parse_quote_spanned! {elem.span()=> - ::fayalite::expr::ToExpr::to_expr(&(#elem)) - }; - } - parse_quote_spanned! {span=> - ::fayalite::expr::ToExpr::to_expr(&#expr_array) - } + self.require_normal_module_or_fn(hdl_attr); + for elem in &mut expr_array.elems { + *elem = parse_quote_spanned! {elem.span()=> + ::fayalite::expr::ToExpr::to_expr(&(#elem)) + }; } + parse_quote! {::fayalite::expr::ToExpr::to_expr(&#expr_array)} } pub(crate) fn process_hdl_repeat( &mut self, - hdl_attr: HdlAttr, + hdl_attr: HdlAttr, mut expr_repeat: ExprRepeat, ) -> Expr { + self.require_normal_module_or_fn(hdl_attr); let repeated_value = &expr_repeat.expr; - let ExprOptions { sim } = hdl_attr.body; - let span = hdl_attr.kw.span; - if sim.is_some() { - *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> - ::fayalite::sim::value::ToSimValue::to_sim_value(&(#repeated_value)) - }; - parse_quote_spanned! {span=> - ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_repeat) - } - } else { - *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> - ::fayalite::expr::ToExpr::to_expr(&(#repeated_value)) - }; - parse_quote_spanned! {span=> - ::fayalite::expr::ToExpr::to_expr(&#expr_repeat) - } - } + *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> + ::fayalite::expr::ToExpr::to_expr(&(#repeated_value)) + }; + parse_quote! {::fayalite::expr::ToExpr::to_expr(&#expr_repeat)} } pub(crate) fn process_hdl_struct( &mut self, - hdl_attr: HdlAttr, - mut expr_struct: ExprStruct, + hdl_attr: HdlAttr, + expr_struct: ExprStruct, ) -> Expr { + self.require_normal_module_or_fn(&hdl_attr); let name_span = expr_struct.path.segments.last().unwrap().ident.span(); - let ExprOptions { sim } = hdl_attr.body; - if sim.is_some() { - let ty_path = TypePath { - qself: expr_struct.qself.take(), - path: expr_struct.path, - }; - expr_struct.path = parse_quote_spanned! {name_span=> - __SimValue::<#ty_path> - }; - for field in &mut expr_struct.fields { - let expr = &field.expr; - field.expr = parse_quote_spanned! {field.member.span()=> - ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)) - }; - } - return parse_quote_spanned! {name_span=> - { - type __SimValue = ::SimValue; - let value: ::fayalite::sim::value::SimValue<#ty_path> = ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_struct); - value - } - }; - } let builder_ident = format_ident!("__builder", span = name_span); let empty_builder = if expr_struct.qself.is_some() || expr_struct @@ -149,126 +91,12 @@ impl Visitor<'_> { } pub(crate) fn process_hdl_tuple( &mut self, - hdl_attr: HdlAttr, - mut expr_tuple: ExprTuple, + hdl_attr: HdlAttr, + expr_tuple: ExprTuple, ) -> Expr { - let ExprOptions { sim } = hdl_attr.body; - if sim.is_some() { - for element in &mut expr_tuple.elems { - *element = parse_quote_spanned! {element.span()=> - &(#element) - }; - } - parse_quote_spanned! {expr_tuple.span()=> - ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_tuple) - } - } else { - parse_quote_spanned! {expr_tuple.span()=> - ::fayalite::expr::ToExpr::to_expr(&#expr_tuple) - } + self.require_normal_module_or_fn(hdl_attr); + parse_quote_spanned! {expr_tuple.span()=> + ::fayalite::expr::ToExpr::to_expr(&#expr_tuple) } } - pub(crate) fn process_hdl_call( - &mut self, - hdl_attr: HdlAttr, - mut expr_call: ExprCall, - ) -> Expr { - let span = hdl_attr.kw.span; - let mut func = &mut *expr_call.func; - let EnumPath { - variant_path: _, - enum_path, - variant_name, - } = loop { - match func { - Expr::Group(ExprGroup { expr, .. }) | Expr::Paren(ExprParen { expr, .. }) => { - func = &mut **expr; - } - Expr::Path(_) => { - let Expr::Path(ExprPath { attrs, qself, path }) = - mem::replace(func, Expr::PLACEHOLDER) - else { - unreachable!(); - }; - match parse_enum_path(TypePath { qself, path }) { - Ok(path) => break path, - Err(path) => { - self.errors.error(&path, "unsupported enum variant path"); - let TypePath { qself, path } = path; - *func = ExprPath { attrs, qself, path }.into(); - return expr_call.into(); - } - } - } - _ => { - self.errors.error( - &expr_call.func, - "#[hdl] function call -- function must be a possibly-parenthesized path", - ); - return expr_call.into(); - } - } - }; - self.process_hdl_method_call( - hdl_attr, - ExprMethodCall { - attrs: expr_call.attrs, - receiver: parse_quote_spanned! {span=> - <#enum_path as ::fayalite::ty::StaticType>::TYPE - }, - dot_token: Token![.](span), - method: variant_name, - turbofish: None, - paren_token: expr_call.paren_token, - args: expr_call.args, - }, - ) - } - pub(crate) fn process_hdl_method_call( - &mut self, - hdl_attr: HdlAttr, - mut expr_method_call: ExprMethodCall, - ) -> Expr { - let ExprOptions { sim } = hdl_attr.body; - let span = hdl_attr.kw.span; - // remove any number of groups and up to one paren - let mut receiver = &mut *expr_method_call.receiver; - let mut has_group = false; - let receiver = loop { - match receiver { - Expr::Group(ExprGroup { expr, .. }) => { - has_group = true; - receiver = expr; - } - Expr::Paren(ExprParen { expr, .. }) => break &mut **expr, - receiver @ Expr::Path(_) => break receiver, - _ => { - if !has_group { - self.errors.error( - &expr_method_call.receiver, - "#[hdl] on a method call needs parenthesized receiver", - ); - } - break &mut *expr_method_call.receiver; - } - } - }; - let func = if sim.is_some() { - parse_quote_spanned! {span=> - ::fayalite::enum_::enum_type_to_sim_builder - } - } else { - parse_quote_spanned! {span=> - ::fayalite::enum_::assert_is_enum_type - } - }; - *expr_method_call.receiver = ExprCall { - attrs: vec![], - func, - paren_token: Paren(span), - args: Punctuated::from_iter([mem::replace(receiver, Expr::PLACEHOLDER)]), - } - .into(); - expr_method_call.into() - } } diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs index 68218c1..f1ff2c2 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs @@ -3,9 +3,7 @@ use crate::{ fold::{impl_fold, DoFold}, kw, - module::transform_body::{ - empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, ExprOptions, Visitor, - }, + module::transform_body::{empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, Visitor}, Errors, HdlAttr, PairsIterExt, }; use proc_macro2::{Span, TokenStream}; @@ -13,6 +11,7 @@ use quote::{format_ident, quote_spanned, ToTokens, TokenStreamExt}; use std::collections::BTreeSet; use syn::{ fold::{fold_arm, fold_expr_match, fold_local, fold_pat, Fold}, + parse::Nothing, parse_quote_spanned, punctuated::Punctuated, spanned::Spanned, @@ -83,14 +82,7 @@ visit_trait! { } } fn visit_match_pat_enum_variant(state: _, v: &MatchPatEnumVariant) { - let MatchPatEnumVariant { - match_span:_, - sim:_, - variant_path: _, - enum_path: _, - variant_name: _, - field, - } = v; + let MatchPatEnumVariant {match_span:_, variant_path: _, enum_path: _, variant_name: _, field } = v; if let Some((_, v)) = field { state.visit_match_pat_simple(v); } @@ -300,7 +292,6 @@ impl ToTokens for MatchPatTuple { with_debug_clone_and_fold! { struct MatchPatEnumVariant<> { match_span: Span, - sim: Option<(kw::sim,)>, variant_path: Path, enum_path: Path, variant_name: Ident, @@ -312,7 +303,6 @@ impl ToTokens for MatchPatEnumVariant { fn to_tokens(&self, tokens: &mut TokenStream) { let Self { match_span, - sim, variant_path: _, enum_path, variant_name, @@ -322,28 +312,7 @@ impl ToTokens for MatchPatEnumVariant { __MatchTy::<#enum_path>::#variant_name } .to_tokens(tokens); - if sim.is_some() { - if let Some((paren_token, field)) = field { - paren_token.surround(tokens, |tokens| { - field.to_tokens(tokens); - match field { - MatchPatSimple::Paren(_) - | MatchPatSimple::Or(_) - | MatchPatSimple::Binding(_) - | MatchPatSimple::Wild(_) => quote_spanned! {*match_span=> - , _ - } - .to_tokens(tokens), - MatchPatSimple::Rest(_) => {} - } - }); - } else { - quote_spanned! {*match_span=> - (_) - } - .to_tokens(tokens); - } - } else if let Some((paren_token, field)) = field { + if let Some((paren_token, field)) = field { paren_token.surround(tokens, |tokens| field.to_tokens(tokens)); } } @@ -380,13 +349,13 @@ impl ToTokens for MatchPatSimple { } } -pub(crate) struct EnumPath { - pub(crate) variant_path: Path, - pub(crate) enum_path: Path, - pub(crate) variant_name: Ident, +struct EnumPath { + variant_path: Path, + enum_path: Path, + variant_name: Ident, } -pub(crate) fn parse_enum_path(variant_path: TypePath) -> Result { +fn parse_enum_path(variant_path: TypePath) -> Result { let TypePath { qself: None, path: variant_path, @@ -478,7 +447,6 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, - sim: state.sim, variant_path, enum_path, variant_name, @@ -525,7 +493,6 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, - sim: state.sim, variant_path, enum_path, variant_name, @@ -610,7 +577,6 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, - sim: state.sim, variant_path, enum_path, variant_name, @@ -973,7 +939,6 @@ impl Fold for RewriteAsCheckMatch { } struct HdlMatchParseState<'a> { - sim: Option<(kw::sim,)>, match_span: Span, errors: &'a mut Errors, } @@ -1016,11 +981,10 @@ impl<'a> VisitMatchPat<'a> for HdlLetPatVisitState<'a> { impl Visitor<'_> { pub(crate) fn process_hdl_let_pat( &mut self, - hdl_attr: HdlAttr, + _hdl_attr: HdlAttr, mut let_stmt: Local, ) -> Local { let span = let_stmt.let_token.span(); - let ExprOptions { sim } = hdl_attr.body; if let Pat::Type(pat) = &mut let_stmt.pat { *pat.ty = wrap_ty_with_expr((*pat.ty).clone()); } @@ -1032,6 +996,7 @@ impl Visitor<'_> { init, semi_token, } = let_stmt; + self.require_normal_module_or_fn(let_token); let Some(syn::LocalInit { eq_token, expr, @@ -1050,7 +1015,6 @@ impl Visitor<'_> { } let Ok(pat) = MatchPat::parse( &mut HdlMatchParseState { - sim, match_span: span, errors: &mut self.errors, }, @@ -1067,47 +1031,29 @@ impl Visitor<'_> { errors: _, bindings, } = state; - let retval = if sim.is_some() { - parse_quote_spanned! {span=> - let (#(#bindings,)*) = { - type __MatchTy = ::SimValue; - let __match_value = ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)); - #let_token #pat #eq_token ::fayalite::sim::value::SimValue::into_value(__match_value) #semi_token - (#(#bindings,)*) + let retval = parse_quote_spanned! {span=> + let (#(#bindings,)* __scope,) = { + type __MatchTy = ::MatchVariant; + let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); + ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { + #[allow(unused_variables)] + #check_let_stmt + match __infallible {} + }); + let mut __match_iter = ::fayalite::module::match_(__match_expr); + let ::fayalite::__std::option::Option::Some(__match_variant) = ::fayalite::__std::iter::Iterator::next(&mut __match_iter) else { + ::fayalite::__std::unreachable!("#[hdl] let with uninhabited type"); }; - } - } else { - parse_quote_spanned! {span=> - let (#(#bindings,)* __scope,) = { - type __MatchTy = ::MatchVariant; - let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); - ::fayalite::expr::check_match_expr( - __match_expr, - |__match_value, __infallible| { - #[allow(unused_variables)] - #check_let_stmt - match __infallible {} - }, + let ::fayalite::__std::option::Option::None = ::fayalite::__std::iter::Iterator::next(&mut __match_iter) else { + ::fayalite::__std::unreachable!("#[hdl] let with refutable pattern"); + }; + let (__match_variant, __scope) = + ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( + __match_variant, ); - let mut __match_iter = ::fayalite::module::match_(__match_expr); - let ::fayalite::__std::option::Option::Some(__match_variant) = - ::fayalite::__std::iter::Iterator::next(&mut __match_iter) - else { - ::fayalite::__std::unreachable!("#[hdl] let with uninhabited type"); - }; - let ::fayalite::__std::option::Option::None = - ::fayalite::__std::iter::Iterator::next(&mut __match_iter) - else { - ::fayalite::__std::unreachable!("#[hdl] let with refutable pattern"); - }; - let (__match_variant, __scope) = - ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( - __match_variant, - ); - #let_token #pat #eq_token __match_variant #semi_token - (#(#bindings,)* __scope,) - }; - } + #let_token #pat #eq_token __match_variant #semi_token + (#(#bindings,)* __scope,) + }; }; match retval { syn::Stmt::Local(retval) => retval, @@ -1116,7 +1062,7 @@ impl Visitor<'_> { } pub(crate) fn process_hdl_match( &mut self, - hdl_attr: HdlAttr, + _hdl_attr: HdlAttr, expr_match: ExprMatch, ) -> Expr { let span = expr_match.match_token.span(); @@ -1128,9 +1074,8 @@ impl Visitor<'_> { brace_token: _, arms, } = expr_match; - let ExprOptions { sim } = hdl_attr.body; + self.require_normal_module_or_fn(match_token); let mut state = HdlMatchParseState { - sim, match_span: span, errors: &mut self.errors, }; @@ -1138,36 +1083,24 @@ impl Visitor<'_> { arms.into_iter() .filter_map(|arm| MatchArm::parse(&mut state, arm).ok()), ); - let expr = if sim.is_some() { - quote_spanned! {span=> - { - type __MatchTy = ::SimValue; - let __match_expr = ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)); - #match_token ::fayalite::sim::value::SimValue::into_value(__match_expr) { + let expr = quote_spanned! {span=> + { + type __MatchTy = ::MatchVariant; + let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); + ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { + #[allow(unused_variables)] + #check_match + }); + for __match_variant in ::fayalite::module::match_(__match_expr) { + let (__match_variant, __scope) = + ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( + __match_variant, + ); + #match_token __match_variant { #(#arms)* } } } - } else { - quote_spanned! {span=> - { - type __MatchTy = ::MatchVariant; - let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); - ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { - #[allow(unused_variables)] - #check_match - }); - for __match_variant in ::fayalite::module::match_(__match_expr) { - let (__match_variant, __scope) = - ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( - __match_variant, - ); - #match_token __match_variant { - #(#arms)* - } - } - } - } }; syn::parse2(expr).unwrap() } diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs index 6d9b043..0d9b63f 100644 --- a/crates/fayalite/src/array.rs +++ b/crates/fayalite/src/array.rs @@ -9,16 +9,12 @@ use crate::{ int::{Bool, DynSize, KnownSize, Size, SizeType, DYN_SIZE}, intern::{Intern, Interned, LazyInterned}, module::transform::visit::{Fold, Folder, Visit, Visitor}, - sim::value::{SimValue, SimValuePartialEq}, source_location::SourceLocation, ty::{ - serde_impls::SerdeCanonicalType, CanonicalType, MatchVariantWithoutScope, StaticType, Type, - TypeProperties, TypeWithDeref, + CanonicalType, MatchVariantWithoutScope, StaticType, Type, TypeProperties, TypeWithDeref, }, util::ConstUsize, }; -use bitvec::slice::BitSlice; -use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer}; use std::{iter::FusedIterator, ops::Index}; #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -98,12 +94,6 @@ impl> ArrayType { } } -impl Default for ArrayType { - fn default() -> Self { - Self::TYPE - } -} - impl StaticType for ArrayType { const TYPE: Self = Self { element: LazyInterned::new_lazy(&|| T::TYPE.intern_sized()), @@ -152,7 +142,6 @@ impl, Len: Size, State: Visitor + ?Sized> Visit impl Type for ArrayType { type BaseType = Array; type MaskType = ArrayType; - type SimValue = Len::ArraySimValue; type MatchVariant = Len::ArrayMatch; type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope>; @@ -189,92 +178,9 @@ impl Type for ArrayType { Len::from_usize(array.len()), ) } - fn source_location() -> SourceLocation { SourceLocation::builtin() } - - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), self.type_properties.bit_width); - let element = self.element(); - let element_bit_width = element.canonical().bit_width(); - TryFrom::try_from(Vec::from_iter((0..self.len()).map(|i| { - SimValue::from_bitslice(element, &bits[i * element_bit_width..][..element_bit_width]) - }))) - .ok() - .expect("used correct length") - } - - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), self.type_properties.bit_width); - let element_ty = self.element(); - let element_bit_width = element_ty.canonical().bit_width(); - let value: &mut [SimValue] = value.as_mut(); - assert_eq!(self.len(), value.len()); - for (i, element_value) in value.iter_mut().enumerate() { - assert_eq!(SimValue::ty(element_value), element_ty); - SimValue::bits_mut(element_value) - .bits_mut() - .copy_from_bitslice(&bits[i * element_bit_width..][..element_bit_width]); - } - } - - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), self.type_properties.bit_width); - let element_ty = self.element(); - let element_bit_width = element_ty.canonical().bit_width(); - let value: &[SimValue] = value.as_ref(); - assert_eq!(self.len(), value.len()); - for (i, element_value) in value.iter().enumerate() { - assert_eq!(SimValue::ty(element_value), element_ty); - bits[i * element_bit_width..][..element_bit_width] - .copy_from_bitslice(SimValue::bits(element_value).bits()); - } - } -} - -impl Serialize for ArrayType { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - SerdeCanonicalType::::Array { - element: self.element(), - len: self.len(), - } - .serialize(serializer) - } -} - -impl<'de, T: Type + Deserialize<'de>, Len: Size> Deserialize<'de> for ArrayType { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let name = |len| -> String { - if let Some(len) = len { - format!("an Array<_, {len}>") - } else { - "an Array<_>".to_string() - } - }; - match SerdeCanonicalType::::deserialize(deserializer)? { - SerdeCanonicalType::Array { element, len } => { - if let Some(len) = Len::try_from_usize(len) { - Ok(Self::new(element, len)) - } else { - Err(Error::invalid_value( - serde::de::Unexpected::Other(&name(Some(len))), - &&*name(Len::KNOWN_VALUE), - )) - } - } - ty => Err(Error::invalid_value( - serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), - &&*name(Len::KNOWN_VALUE), - )), - } - } } impl TypeWithDeref for ArrayType { @@ -341,18 +247,6 @@ where } } -impl SimValuePartialEq> for ArrayType -where - Lhs: SimValuePartialEq, -{ - fn sim_value_eq(this: &SimValue, other: &SimValue>) -> bool { - AsRef::<[_]>::as_ref(&**this) - .iter() - .zip(AsRef::<[_]>::as_ref(&**other)) - .all(|(l, r)| SimValuePartialEq::sim_value_eq(l, r)) - } -} - impl ExprIntoIterator for ArrayType { type Item = T; type ExprIntoIter = ExprArrayIter; diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs index 0fd89f1..9807b92 100644 --- a/crates/fayalite/src/bundle.rs +++ b/crates/fayalite/src/bundle.rs @@ -8,19 +8,18 @@ use crate::{ }, int::{Bool, DynSize}, intern::{Intern, Interned}, - sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, + sim::{SimValue, ToSimValue}, source_location::SourceLocation, ty::{ - impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, - StaticType, Type, TypeProperties, TypeWithDeref, + impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, StaticType, Type, + TypeProperties, TypeWithDeref, }, }; -use bitvec::{slice::BitSlice, vec::BitVec}; +use bitvec::vec::BitVec; use hashbrown::HashMap; -use serde::{Deserialize, Serialize}; use std::{fmt, marker::PhantomData}; -#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)] +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct BundleField { pub name: Interned, pub flipped: bool, @@ -217,7 +216,6 @@ impl Bundle { impl Type for Bundle { type BaseType = Bundle; type MaskType = Bundle; - type SimValue = OpaqueSimValue; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { Self::new(Interned::from_iter(self.0.fields.into_iter().map( @@ -241,20 +239,6 @@ impl Type for Bundle { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), self.type_properties().bit_width); - OpaqueSimValue::from_bitslice(bits) - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), self.type_properties().bit_width); - assert_eq!(value.bit_width(), self.type_properties().bit_width); - value.bits_mut().bits_mut().copy_from_bitslice(bits); - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), self.type_properties().bit_width); - assert_eq!(value.bit_width(), self.type_properties().bit_width); - bits.copy_from_bitslice(value.bits().bits()); - } } pub trait BundleType: Type { @@ -263,93 +247,6 @@ pub trait BundleType: Type { fn fields(&self) -> Interned<[BundleField]>; } -pub struct BundleSimValueFromBits<'a> { - fields: std::slice::Iter<'static, BundleField>, - bits: &'a BitSlice, -} - -impl<'a> BundleSimValueFromBits<'a> { - #[track_caller] - pub fn new(bundle_ty: T, bits: &'a BitSlice) -> Self { - let fields = bundle_ty.fields(); - assert_eq!( - bits.len(), - fields - .iter() - .map(|BundleField { ty, .. }| ty.bit_width()) - .sum::() - ); - Self { - fields: Interned::into_inner(fields).iter(), - bits, - } - } - #[track_caller] - fn field_ty_and_bits(&mut self) -> (T, &'a BitSlice) { - let Some(&BundleField { - name: _, - flipped: _, - ty, - }) = self.fields.next() - else { - panic!("tried to read too many fields from BundleSimValueFromBits"); - }; - let (field_bits, rest) = self.bits.split_at(ty.bit_width()); - self.bits = rest; - (T::from_canonical(ty), field_bits) - } - #[track_caller] - pub fn field_from_bits(&mut self) -> SimValue { - let (field_ty, field_bits) = self.field_ty_and_bits::(); - SimValue::from_bitslice(field_ty, field_bits) - } - #[track_caller] - pub fn field_clone_from_bits(&mut self, field_value: &mut SimValue) { - let (field_ty, field_bits) = self.field_ty_and_bits::(); - assert_eq!(field_ty, SimValue::ty(field_value)); - SimValue::bits_mut(field_value) - .bits_mut() - .copy_from_bitslice(field_bits); - } -} - -pub struct BundleSimValueToBits<'a> { - fields: std::slice::Iter<'static, BundleField>, - bits: &'a mut BitSlice, -} - -impl<'a> BundleSimValueToBits<'a> { - #[track_caller] - pub fn new(bundle_ty: T, bits: &'a mut BitSlice) -> Self { - let fields = bundle_ty.fields(); - assert_eq!( - bits.len(), - fields - .iter() - .map(|BundleField { ty, .. }| ty.bit_width()) - .sum::() - ); - Self { - fields: Interned::into_inner(fields).iter(), - bits, - } - } - #[track_caller] - pub fn field_to_bits(&mut self, field_value: &SimValue) { - let Some(&BundleField { - name: _, - flipped: _, - ty, - }) = self.fields.next() - else { - panic!("tried to read too many fields from BundleSimValueFromBits"); - }; - assert_eq!(T::from_canonical(ty), SimValue::ty(field_value)); - self.bits[..ty.bit_width()].copy_from_bitslice(SimValue::bits(field_value).bits()); - self.bits = &mut std::mem::take(&mut self.bits)[ty.bit_width()..]; - } -} - #[derive(Default)] pub struct NoBuilder; @@ -456,7 +353,6 @@ macro_rules! impl_tuples { impl<$($T: Type,)*> Type for ($($T,)*) { type BaseType = Bundle; type MaskType = ($($T::MaskType,)*); - type SimValue = ($(SimValue<$T>,)*); type MatchVariant = ($(Expr<$T>,)*); type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope; @@ -495,24 +391,6 @@ macro_rules! impl_tuples { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - #![allow(unused_mut, unused_variables)] - let mut v = BundleSimValueFromBits::new(*self, bits); - $(let $var = v.field_from_bits();)* - ($($var,)*) - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - #![allow(unused_mut, unused_variables)] - let mut v = BundleSimValueFromBits::new(*self, bits); - let ($($var,)*) = value; - $(v.field_clone_from_bits($var);)* - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - #![allow(unused_mut, unused_variables)] - let mut v = BundleSimValueToBits::new(*self, bits); - let ($($var,)*) = value; - $(v.field_to_bits($var);)* - } } impl<$($T: Type,)*> BundleType for ($($T,)*) { type Builder = TupleBuilder<($(Unfilled<$T>,)*)>; @@ -563,72 +441,77 @@ macro_rules! impl_tuples { BundleLiteral::new(ty, field_values[..].intern()).to_expr() } } - impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { + impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValueWithType::::to_sim_value_with_type(self, Bundle::from_canonical(ty))) + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + ToSimValue::::to_sim_value(self, Bundle::from_canonical(ty)).into_canonical() } #[track_caller] - fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue + fn into_sim_value(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValueWithType::::into_sim_value_with_type(self, Bundle::from_canonical(ty))) + ToSimValue::::into_sim_value(self, Bundle::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: CanonicalType) -> SimValue { + ToSimValue::::box_into_sim_value(self, Bundle::from_canonical(ty)).into_canonical() } } - impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { + impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { #[track_caller] - fn to_sim_value_with_type(&self, ty: Bundle) -> SimValue { + fn to_sim_value(&self, ty: Bundle) -> SimValue { let ($($var,)*) = self; let [$($ty_var,)*] = *ty.fields() else { panic!("bundle has wrong number of fields"); }; - $(let $var = $var.to_sim_value_with_type($ty_var.ty);)* - ToSimValueWithType::into_sim_value_with_type(($($var,)*), ty) + $(let $var = $var.to_sim_value($ty_var.ty);)* + ToSimValue::into_sim_value(($($var,)*), ty) } #[track_caller] - fn into_sim_value_with_type(self, ty: Bundle) -> SimValue { + fn into_sim_value(self, ty: Bundle) -> SimValue { #![allow(unused_mut)] #![allow(clippy::unused_unit)] let ($($var,)*) = self; let [$($ty_var,)*] = *ty.fields() else { panic!("bundle has wrong number of fields"); }; - let mut bits = BitVec::new(); - $(let $var = $var.into_sim_value_with_type($ty_var.ty); - assert_eq!(SimValue::ty(&$var), $ty_var.ty); - bits.extend_from_bitslice(SimValue::bits(&$var).bits()); + let mut bits: Option = None; + $(let $var = $var.into_sim_value($ty_var.ty); + assert_eq!($var.ty(), $ty_var.ty); + if !$var.bits().is_empty() { + if let Some(bits) = &mut bits { + bits.extend_from_bitslice($var.bits()); + } else { + let mut $var = $var.into_bits(); + $var.reserve(ty.type_properties().bit_width - $var.len()); + bits = Some($var); + } + } )* - bits.into_sim_value_with_type(ty) + bits.unwrap_or_else(BitVec::new).into_sim_value(ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: Bundle) -> SimValue { + Self::into_sim_value(*self, ty) } } - impl<$($T: ToSimValueWithType<$Ty>, $Ty: Type,)*> ToSimValueWithType<($($Ty,)*)> for ($($T,)*) { + impl<$($T: ToSimValue<$Ty>, $Ty: Type,)*> ToSimValue<($($Ty,)*)> for ($($T,)*) { #[track_caller] - fn to_sim_value_with_type(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn to_sim_value(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.to_sim_value_with_type($ty_var);)* - SimValue::from_value(ty, ($($var,)*)) + $(let $var = $var.to_sim_value($ty_var).into_canonical();)* + SimValue::from_canonical(ToSimValue::into_sim_value(($($var,)*), ty.canonical())) } #[track_caller] - fn into_sim_value_with_type(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn into_sim_value(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.into_sim_value_with_type($ty_var);)* - SimValue::from_value(ty, ($($var,)*)) - } - } - impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { - type Type = ($($T::Type,)*); - #[track_caller] - fn to_sim_value(&self) -> SimValue { - let ($($var,)*) = self; - $(let $var = $var.to_sim_value();)* - SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*)) + $(let $var = $var.into_sim_value($ty_var).into_canonical();)* + SimValue::from_canonical(ToSimValue::into_sim_value(($($var,)*), ty.canonical())) } #[track_caller] - fn into_sim_value(self) -> SimValue { - let ($($var,)*) = self; - $(let $var = $var.to_sim_value();)* - SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*)) + fn box_into_sim_value(self: Box, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + Self::into_sim_value(*self, ty) } } impl<$($Lhs: Type + ExprPartialEq<$Rhs>, $Rhs: Type,)*> ExprPartialEq<($($Rhs,)*)> for ($($Lhs,)*) { @@ -654,15 +537,6 @@ macro_rules! impl_tuples { .any_one_bits() } } - impl<$($Lhs: SimValuePartialEq<$Rhs>, $Rhs: Type,)*> SimValuePartialEq<($($Rhs,)*)> for ($($Lhs,)*) { - fn sim_value_eq(lhs: &SimValue, rhs: &SimValue<($($Rhs,)*)>) -> bool { - let ($($lhs_var,)*) = &**lhs; - let ($($rhs_var,)*) = &**rhs; - let retval = true; - $(let retval = retval && $lhs_var == $rhs_var;)* - retval - } - } }; ([$($lhs:tt)*] [$rhs_first:tt $($rhs:tt)*]) => { impl_tuples!([$($lhs)*] []); @@ -690,7 +564,6 @@ impl_tuples! { impl Type for PhantomData { type BaseType = Bundle; type MaskType = (); - type SimValue = PhantomData; type MatchVariant = PhantomData; type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope; @@ -723,16 +596,6 @@ impl Type for PhantomData { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert!(bits.is_empty()); - *self - } - fn sim_value_clone_from_bits(&self, _value: &mut Self::SimValue, bits: &BitSlice) { - assert!(bits.is_empty()); - } - fn sim_value_to_bits(&self, _value: &Self::SimValue, bits: &mut BitSlice) { - assert!(bits.is_empty()); - } } pub struct PhantomDataBuilder(PhantomData); @@ -780,38 +643,26 @@ impl ToExpr for PhantomData { } } -impl ToSimValue for PhantomData { - type Type = PhantomData; - +impl ToSimValue for PhantomData { #[track_caller] - fn to_sim_value(&self) -> SimValue { - SimValue::from_value(*self, *self) + fn to_sim_value(&self, ty: Self) -> SimValue { + ToSimValue::into_sim_value(BitVec::new(), ty) } } -impl ToSimValueWithType for PhantomData { +impl ToSimValue for PhantomData { #[track_caller] - fn to_sim_value_with_type(&self, ty: Self) -> SimValue { - SimValue::from_value(ty, *self) - } -} - -impl ToSimValueWithType for PhantomData { - #[track_caller] - fn to_sim_value_with_type(&self, ty: Bundle) -> SimValue { + fn to_sim_value(&self, ty: Bundle) -> SimValue { assert!(ty.fields().is_empty()); - ToSimValueWithType::into_sim_value_with_type(BitVec::new(), ty) + ToSimValue::into_sim_value(BitVec::new(), ty) } } -impl ToSimValueWithType for PhantomData { +impl ToSimValue for PhantomData { #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { let ty = Bundle::from_canonical(ty); assert!(ty.fields().is_empty()); - SimValue::into_canonical(ToSimValueWithType::into_sim_value_with_type( - BitVec::new(), - ty, - )) + ToSimValue::into_sim_value(BitVec::new(), ty).into_canonical() } } diff --git a/crates/fayalite/src/clock.rs b/crates/fayalite/src/clock.rs index f0623d4..711432b 100644 --- a/crates/fayalite/src/clock.rs +++ b/crates/fayalite/src/clock.rs @@ -8,7 +8,6 @@ use crate::{ source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; -use bitvec::slice::BitSlice; #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)] pub struct Clock; @@ -16,7 +15,6 @@ pub struct Clock; impl Type for Clock { type BaseType = Clock; type MaskType = Bool; - type SimValue = bool; impl_match_variant_as_self!(); @@ -38,21 +36,6 @@ impl Type for Clock { }; retval } - - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), 1); - bits[0] - } - - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), 1); - *value = bits[0]; - } - - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), 1); - bits.set(0, *value); - } } impl Clock { diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs index 6205855..70c58c0 100644 --- a/crates/fayalite/src/enum_.rs +++ b/crates/fayalite/src/enum_.rs @@ -7,25 +7,19 @@ use crate::{ Expr, ToExpr, }, hdl, - int::{Bool, UIntValue}, + int::Bool, intern::{Intern, Interned}, module::{ connect, enum_match_variants_helper, incomplete_wire, wire, EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope, }, - sim::value::{SimValue, SimValuePartialEq}, source_location::SourceLocation, - ty::{ - CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, StaticType, Type, - TypeProperties, - }, + ty::{CanonicalType, MatchVariantAndInactiveScope, StaticType, Type, TypeProperties}, }; -use bitvec::{order::Lsb0, slice::BitSlice, view::BitView}; use hashbrown::HashMap; -use serde::{Deserialize, Serialize}; -use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc}; +use std::{convert::Infallible, fmt, iter::FusedIterator}; -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct EnumVariant { pub name: Interned, pub ty: Option, @@ -158,12 +152,6 @@ impl EnumTypePropertiesBuilder { variant_count: variant_count + 1, } } - #[must_use] - pub fn variants(self, variants: impl IntoIterator) -> Self { - variants.into_iter().fold(self, |this, variant| { - this.variant(variant.ty.map(CanonicalType::type_properties)) - }) - } pub const fn finish(self) -> TypeProperties { assert!( self.variant_count != 0, @@ -260,7 +248,6 @@ pub trait EnumType: MatchVariantsIter = EnumMatchVariantsIter, > { - type SimBuilder: From; fn variants(&self) -> Interned<[EnumVariant]>; fn match_activate_scope( v: Self::MatchVariantAndInactiveScope, @@ -323,18 +310,7 @@ impl DoubleEndedIterator for EnumMatchVariantsIter { } } -pub struct NoBuilder { - _ty: Enum, -} - -impl From for NoBuilder { - fn from(_ty: Enum) -> Self { - Self { _ty } - } -} - impl EnumType for Enum { - type SimBuilder = NoBuilder; fn match_activate_scope( v: Self::MatchVariantAndInactiveScope, ) -> (Self::MatchVariant, Self::MatchActiveScope) { @@ -349,7 +325,6 @@ impl EnumType for Enum { impl Type for Enum { type BaseType = Enum; type MaskType = Bool; - type SimValue = OpaqueSimValue; type MatchVariant = Option>; type MatchActiveScope = Scope; type MatchVariantAndInactiveScope = EnumMatchVariantAndInactiveScope; @@ -380,309 +355,6 @@ impl Type for Enum { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), self.type_properties().bit_width); - OpaqueSimValue::from_bitslice(bits) - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), self.type_properties().bit_width); - assert_eq!(value.bit_width(), self.type_properties().bit_width); - value.bits_mut().bits_mut().copy_from_bitslice(bits); - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), self.type_properties().bit_width); - assert_eq!(value.bit_width(), self.type_properties().bit_width); - bits.copy_from_bitslice(value.bits().bits()); - } -} - -#[derive(Clone, PartialEq, Eq, Hash, Debug, Default)] -pub struct EnumPaddingSimValue { - bits: Option, -} - -impl EnumPaddingSimValue { - pub const fn new() -> Self { - Self { bits: None } - } - pub fn bit_width(&self) -> Option { - self.bits.as_ref().map(UIntValue::width) - } - pub fn bits(&self) -> &Option { - &self.bits - } - pub fn bits_mut(&mut self) -> &mut Option { - &mut self.bits - } - pub fn into_bits(self) -> Option { - self.bits - } - pub fn from_bits(bits: Option) -> Self { - Self { bits } - } - pub fn from_bitslice(v: &BitSlice) -> Self { - Self { - bits: Some(UIntValue::new(Arc::new(v.to_bitvec()))), - } - } -} - -#[derive(Clone, PartialEq, Eq, Hash, Debug)] -pub struct UnknownVariantSimValue { - discriminant: usize, - body_bits: UIntValue, -} - -impl UnknownVariantSimValue { - pub fn discriminant(&self) -> usize { - self.discriminant - } - pub fn body_bits(&self) -> &UIntValue { - &self.body_bits - } - pub fn body_bits_mut(&mut self) -> &mut UIntValue { - &mut self.body_bits - } - pub fn into_body_bits(self) -> UIntValue { - self.body_bits - } - pub fn into_parts(self) -> (usize, UIntValue) { - (self.discriminant, self.body_bits) - } - pub fn new(discriminant: usize, body_bits: UIntValue) -> Self { - Self { - discriminant, - body_bits, - } - } -} - -pub struct EnumSimValueFromBits<'a> { - variants: Interned<[EnumVariant]>, - discriminant: usize, - body_bits: &'a BitSlice, -} - -impl<'a> EnumSimValueFromBits<'a> { - #[track_caller] - pub fn new(ty: T, bits: &'a BitSlice) -> Self { - let variants = ty.variants(); - let bit_width = EnumTypePropertiesBuilder::new() - .variants(variants) - .finish() - .bit_width; - assert_eq!(bit_width, bits.len()); - let (discriminant_bits, body_bits) = - bits.split_at(discriminant_bit_width_impl(variants.len())); - let mut discriminant = 0usize; - discriminant.view_bits_mut::()[..discriminant_bits.len()] - .copy_from_bitslice(discriminant_bits); - Self { - variants, - discriminant, - body_bits, - } - } - pub fn discriminant(&self) -> usize { - self.discriminant - } - #[track_caller] - #[cold] - fn usage_error(&self, clone: bool) -> ! { - let clone = if clone { "clone_" } else { "" }; - match self.variants.get(self.discriminant) { - None => { - panic!("should have called EnumSimValueFromBits::unknown_variant_{clone}from_bits"); - } - Some(EnumVariant { ty: None, .. }) => { - panic!( - "should have called EnumSimValueFromBits::variant_no_field_{clone}from_bits" - ); - } - Some(EnumVariant { ty: Some(_), .. }) => { - panic!( - "should have called EnumSimValueFromBits::variant_with_field_{clone}from_bits" - ); - } - } - } - #[track_caller] - fn known_variant(&self, clone: bool) -> (Option, &'a BitSlice, &'a BitSlice) { - let Some(EnumVariant { ty, .. }) = self.variants.get(self.discriminant) else { - self.usage_error(clone); - }; - let variant_bit_width = ty.map_or(0, CanonicalType::bit_width); - let (variant_bits, padding_bits) = self.body_bits.split_at(variant_bit_width); - (*ty, variant_bits, padding_bits) - } - #[track_caller] - pub fn unknown_variant_from_bits(self) -> UnknownVariantSimValue { - let None = self.variants.get(self.discriminant) else { - self.usage_error(false); - }; - UnknownVariantSimValue::new( - self.discriminant, - UIntValue::new(Arc::new(self.body_bits.to_bitvec())), - ) - } - #[track_caller] - pub fn unknown_variant_clone_from_bits(self, value: &mut UnknownVariantSimValue) { - let None = self.variants.get(self.discriminant) else { - self.usage_error(true); - }; - value.discriminant = self.discriminant; - assert_eq!(value.body_bits.width(), self.body_bits.len()); - value - .body_bits - .bits_mut() - .copy_from_bitslice(self.body_bits); - } - #[track_caller] - pub fn variant_no_field_from_bits(self) -> EnumPaddingSimValue { - let (None, _variant_bits, padding_bits) = self.known_variant(false) else { - self.usage_error(false); - }; - EnumPaddingSimValue::from_bitslice(padding_bits) - } - #[track_caller] - pub fn variant_with_field_from_bits(self) -> (SimValue, EnumPaddingSimValue) { - let (Some(variant_ty), variant_bits, padding_bits) = self.known_variant(false) else { - self.usage_error(false); - }; - ( - SimValue::from_bitslice(T::from_canonical(variant_ty), variant_bits), - EnumPaddingSimValue::from_bitslice(padding_bits), - ) - } - #[track_caller] - fn clone_padding_from_bits(padding: &mut EnumPaddingSimValue, padding_bits: &BitSlice) { - match padding.bits_mut() { - None => *padding = EnumPaddingSimValue::from_bitslice(padding_bits), - Some(padding) => { - assert_eq!(padding.width(), padding_bits.len()); - padding.bits_mut().copy_from_bitslice(padding_bits); - } - } - } - #[track_caller] - pub fn variant_no_field_clone_from_bits(self, padding: &mut EnumPaddingSimValue) { - let (None, _variant_bits, padding_bits) = self.known_variant(true) else { - self.usage_error(true); - }; - Self::clone_padding_from_bits(padding, padding_bits); - } - #[track_caller] - pub fn variant_with_field_clone_from_bits( - self, - value: &mut SimValue, - padding: &mut EnumPaddingSimValue, - ) { - let (Some(variant_ty), variant_bits, padding_bits) = self.known_variant(true) else { - self.usage_error(true); - }; - assert_eq!(SimValue::ty(value), T::from_canonical(variant_ty)); - SimValue::bits_mut(value) - .bits_mut() - .copy_from_bitslice(variant_bits); - Self::clone_padding_from_bits(padding, padding_bits); - } -} - -pub struct EnumSimValueToBits<'a> { - variants: Interned<[EnumVariant]>, - bit_width: usize, - discriminant_bit_width: usize, - bits: &'a mut BitSlice, -} - -impl<'a> EnumSimValueToBits<'a> { - #[track_caller] - pub fn new(ty: T, bits: &'a mut BitSlice) -> Self { - let variants = ty.variants(); - let bit_width = EnumTypePropertiesBuilder::new() - .variants(variants) - .finish() - .bit_width; - assert_eq!(bit_width, bits.len()); - Self { - variants, - bit_width, - discriminant_bit_width: discriminant_bit_width_impl(variants.len()), - bits, - } - } - #[track_caller] - fn discriminant_to_bits(&mut self, mut discriminant: usize) { - let orig_discriminant = discriminant; - let discriminant_bits = - &mut discriminant.view_bits_mut::()[..self.discriminant_bit_width]; - self.bits[..self.discriminant_bit_width].copy_from_bitslice(discriminant_bits); - discriminant_bits.fill(false); - assert!( - discriminant == 0, - "{orig_discriminant:#x} is too big to fit in enum discriminant bits", - ); - } - #[track_caller] - pub fn unknown_variant_to_bits(mut self, value: &UnknownVariantSimValue) { - self.discriminant_to_bits(value.discriminant); - let None = self.variants.get(value.discriminant) else { - panic!("can't use UnknownVariantSimValue to set known discriminant"); - }; - assert_eq!( - self.bit_width - self.discriminant_bit_width, - value.body_bits.width() - ); - self.bits[self.discriminant_bit_width..].copy_from_bitslice(value.body_bits.bits()); - } - #[track_caller] - fn known_variant( - mut self, - discriminant: usize, - padding: &EnumPaddingSimValue, - ) -> (Option, &'a mut BitSlice) { - self.discriminant_to_bits(discriminant); - let variant_ty = self.variants[discriminant].ty; - let variant_bit_width = variant_ty.map_or(0, CanonicalType::bit_width); - let padding_bits = &mut self.bits[self.discriminant_bit_width..][variant_bit_width..]; - if let Some(padding) = padding.bits() { - assert_eq!(padding.width(), padding_bits.len()); - padding_bits.copy_from_bitslice(padding.bits()); - } else { - padding_bits.fill(false); - } - let variant_bits = &mut self.bits[self.discriminant_bit_width..][..variant_bit_width]; - (variant_ty, variant_bits) - } - #[track_caller] - pub fn variant_no_field_to_bits(self, discriminant: usize, padding: &EnumPaddingSimValue) { - let (None, _variant_bits) = self.known_variant(discriminant, padding) else { - panic!("expected variant to have no field"); - }; - } - #[track_caller] - pub fn variant_with_field_to_bits( - self, - discriminant: usize, - value: &SimValue, - padding: &EnumPaddingSimValue, - ) { - let (Some(variant_ty), variant_bits) = self.known_variant(discriminant, padding) else { - panic!("expected variant to have a field"); - }; - assert_eq!(SimValue::ty(value), T::from_canonical(variant_ty)); - variant_bits.copy_from_bitslice(SimValue::bits(value).bits()); - } -} - -#[doc(hidden)] -pub fn assert_is_enum_type(v: T) -> T { - v -} - -#[doc(hidden)] -pub fn enum_type_to_sim_builder(v: T) -> T::SimBuilder { - v.into() } #[hdl] @@ -745,25 +417,6 @@ impl, Rhs: Type> ExprPartialEq> fo } } -impl, Rhs: Type> SimValuePartialEq> for HdlOption { - fn sim_value_eq(this: &SimValue, other: &SimValue>) -> bool { - type SimValueMatch = ::SimValue; - match (&**this, &**other) { - (SimValueMatch::::HdlNone(_), SimValueMatch::>::HdlNone(_)) => { - true - } - (SimValueMatch::::HdlSome(..), SimValueMatch::>::HdlNone(_)) - | (SimValueMatch::::HdlNone(_), SimValueMatch::>::HdlSome(..)) => { - false - } - ( - SimValueMatch::::HdlSome(l, _), - SimValueMatch::>::HdlSome(r, _), - ) => l == r, - } - } -} - #[allow(non_snake_case)] pub fn HdlNone() -> Expr> { HdlOption[T::TYPE].HdlNone() diff --git a/crates/fayalite/src/expr.rs b/crates/fayalite/src/expr.rs index f511c97..016ec8e 100644 --- a/crates/fayalite/src/expr.rs +++ b/crates/fayalite/src/expr.rs @@ -700,7 +700,6 @@ impl CastToBits for T { } pub trait CastBitsTo { - #[track_caller] fn cast_bits_to(&self, ty: T) -> Expr; } diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs index 13b8cf1..236f240 100644 --- a/crates/fayalite/src/int.rs +++ b/crates/fayalite/src/int.rs @@ -2,31 +2,24 @@ // See Notices.txt for copyright information use crate::{ - array::ArrayType, expr::{ target::{GetTarget, Target}, Expr, NotALiteralExpr, ToExpr, ToLiteralBits, }, intern::{Intern, Interned, Memoize}, - sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize}, }; -use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec, view::BitView}; +use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec}; use num_bigint::{BigInt, BigUint, Sign}; -use num_traits::{One, Signed, Zero}; -use serde::{ - de::{DeserializeOwned, Error, Visitor}, - Deserialize, Deserializer, Serialize, Serializer, -}; +use num_traits::{Signed, Zero}; use std::{ borrow::{BorrowMut, Cow}, fmt, marker::PhantomData, num::NonZero, ops::{Bound, Index, Not, Range, RangeBounds, RangeInclusive}, - str::FromStr, sync::Arc, }; @@ -56,16 +49,6 @@ pub trait KnownSize: + IntoIterator> + TryFrom>> + Into>>; - type ArraySimValue: AsRef<[SimValue]> - + AsMut<[SimValue]> - + BorrowMut<[SimValue]> - + 'static - + Clone - + std::fmt::Debug - + IntoIterator> - + TryFrom>> - + Into>> - + ToSimValueWithType>; } macro_rules! known_widths { @@ -77,7 +60,6 @@ macro_rules! known_widths { }> { const SIZE: Self = Self; type ArrayMatch = [Expr; Self::VALUE]; - type ArraySimValue = [SimValue; Self::VALUE]; } }; ([2 $($rest:tt)*] $($bits:literal)+) => { @@ -90,7 +72,6 @@ macro_rules! known_widths { impl KnownSize for ConstUsize<{2 $(* $rest)*}> { const SIZE: Self = Self; type ArrayMatch = [Expr; Self::VALUE]; - type ArraySimValue = [SimValue; Self::VALUE]; } }; } @@ -98,31 +79,13 @@ macro_rules! known_widths { known_widths!([2 2 2 2 2 2 2 2 2]); pub trait SizeType: - sealed::SizeTypeSealed - + Copy - + Ord - + std::hash::Hash - + std::fmt::Debug - + Send - + Sync - + 'static - + Serialize - + DeserializeOwned + sealed::SizeTypeSealed + Copy + Ord + std::hash::Hash + std::fmt::Debug + Send + Sync + 'static { type Size: Size; } pub trait Size: - sealed::SizeSealed - + Copy - + Ord - + std::hash::Hash - + std::fmt::Debug - + Send - + Sync - + 'static - + Serialize - + DeserializeOwned + sealed::SizeSealed + Copy + Ord + std::hash::Hash + std::fmt::Debug + Send + Sync + 'static { type ArrayMatch: AsRef<[Expr]> + AsMut<[Expr]> @@ -137,16 +100,6 @@ pub trait Size: + IntoIterator> + TryFrom>> + Into>>; - type ArraySimValue: AsRef<[SimValue]> - + AsMut<[SimValue]> - + BorrowMut<[SimValue]> - + 'static - + Clone - + std::fmt::Debug - + IntoIterator> - + TryFrom>> - + Into>> - + ToSimValueWithType>; const KNOWN_VALUE: Option; type SizeType: SizeType + Copy @@ -172,7 +125,6 @@ impl SizeType for usize { impl Size for DynSize { type ArrayMatch = Box<[Expr]>; - type ArraySimValue = Box<[SimValue]>; const KNOWN_VALUE: Option = None; type SizeType = usize; @@ -195,7 +147,6 @@ impl SizeType for T { impl Size for T { type ArrayMatch = ::ArrayMatch; - type ArraySimValue = ::ArraySimValue; const KNOWN_VALUE: Option = Some(T::VALUE); @@ -214,305 +165,6 @@ impl Size for T { } } -#[derive(Clone, PartialEq, Eq, Debug)] -pub enum ParseIntValueError { - Empty, - InvalidDigit, - MissingDigits, - InvalidRadix, - MissingType, - InvalidType, - TypeMismatch { - parsed_signed: bool, - parsed_width: usize, - expected_signed: bool, - expected_width: usize, - }, - PosOverflow, - NegOverflow, - WidthOverflow, - MissingWidth, -} - -impl std::error::Error for ParseIntValueError {} - -impl fmt::Display for ParseIntValueError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(match self { - Self::Empty => "can't parse integer from empty string", - Self::InvalidDigit => "invalid digit", - Self::MissingDigits => "missing digits", - Self::InvalidRadix => "invalid radix", - Self::MissingType => "missing type", - Self::InvalidType => "invalid type", - Self::TypeMismatch { - parsed_signed, - parsed_width, - expected_signed, - expected_width, - } => { - return write!( - f, - "type mismatch: parsed type {parsed_signed_str}{parsed_width}, \ - expected type {expected_signed_str}{expected_width}", - parsed_signed_str = if *parsed_signed { "i" } else { "u" }, - expected_signed_str = if *expected_signed { "i" } else { "u" }, - ); - } - Self::PosOverflow => "value too large to fit in type", - Self::NegOverflow => "value too small to fit in type", - Self::WidthOverflow => "width is too large", - Self::MissingWidth => "missing width", - }) - } -} - -fn parse_int_value( - s: &str, - type_is_signed: bool, - type_width: Option, - parse_type: bool, -) -> Result, ParseIntValueError> { - if !parse_type && type_width.is_none() { - return Err(ParseIntValueError::MissingWidth); - } - let mut s = s.trim(); - if s.is_empty() { - return Err(ParseIntValueError::Empty); - } - let negative = match s.bytes().next() { - Some(ch @ (b'+' | b'-')) => { - s = s[1..].trim_start(); - ch == b'-' - } - _ => false, - }; - let radix = match s.bytes().next() { - Some(b'0') => match s.bytes().nth(1) { - Some(b'x' | b'X') => { - s = &s[2..]; - 16 - } - Some(b'b' | b'B') => { - s = &s[2..]; - 2 - } - Some(b'o' | b'O') => { - s = &s[2..]; - 8 - } - _ => 10, - }, - Some(b'1'..=b'9') => 10, - _ => return Err(ParseIntValueError::InvalidDigit), - }; - let mut any_digits = false; - let digits_end = s - .as_bytes() - .iter() - .position(|&ch| { - if ch == b'_' { - false - } else if (ch as char).to_digit(radix).is_some() { - any_digits = true; - false - } else { - true - } - }) - .unwrap_or(s.len()); - let digits = &s[..digits_end]; - s = &s[digits_end..]; - if !any_digits { - return Err(ParseIntValueError::MissingDigits); - } - let width = if parse_type { - const HDL_PREFIX: &[u8] = b"hdl_"; - let mut missing_type = ParseIntValueError::MissingType; - if s.as_bytes() - .get(..HDL_PREFIX.len()) - .is_some_and(|bytes| bytes.eq_ignore_ascii_case(HDL_PREFIX)) - { - s = &s[HDL_PREFIX.len()..]; - missing_type = ParseIntValueError::InvalidType; - } - let signed = match s.bytes().next() { - Some(b'u' | b'U') => false, - Some(b'i' | b'I') => true, - Some(_) => return Err(ParseIntValueError::InvalidType), - None => return Err(missing_type), - }; - s = &s[1..]; - let mut width = 0usize; - let mut any_digits = false; - for ch in s.bytes() { - let digit = (ch as char) - .to_digit(10) - .ok_or(ParseIntValueError::InvalidDigit)?; - any_digits = true; - width = width - .checked_mul(10) - .and_then(|v| v.checked_add(digit as usize)) - .ok_or(ParseIntValueError::WidthOverflow)?; - } - if !any_digits { - return Err(ParseIntValueError::MissingDigits); - } - if width > ::MAX_BITS { - return Err(ParseIntValueError::WidthOverflow); - } - let expected_width = type_width.unwrap_or(width); - if type_is_signed != signed || expected_width != width { - let expected_width = type_width.unwrap_or(width); - return Err(ParseIntValueError::TypeMismatch { - parsed_signed: signed, - parsed_width: width, - expected_signed: type_is_signed, - expected_width, - }); - } - width - } else { - if !s.is_empty() { - return Err(ParseIntValueError::InvalidDigit); - } - type_width.expect("checked earlier") - }; - if !type_is_signed && negative { - return Err(ParseIntValueError::InvalidDigit); - } - if radix == 10 { - let mut value: BigInt = digits - .replace("_", "") - .parse() - .expect("checked that the digits are valid already"); - if negative { - value = -value; - } - let uint_value: UIntValue = UInt::new(width).from_bigint_wrapping(&value); - if value.is_zero() { - Ok(uint_value.into_bits()) - } else { - for i in 0..width { - value.set_bit(i as u64, type_is_signed && negative); - } - if value.is_zero() { - Ok(uint_value.into_bits()) - } else if type_is_signed && negative { - if value.sign() == Sign::Minus && value.magnitude().is_one() { - Ok(uint_value.into_bits()) - } else { - Err(ParseIntValueError::NegOverflow) - } - } else { - Err(ParseIntValueError::PosOverflow) - } - } - } else { - let mut value = BitVec::repeat(false, width); - let bits_per_digit = match radix { - 2 => 1, - 8 => 3, - 16 => 4, - _ => unreachable!(), - }; - let mut digits = digits - .bytes() - .rev() - .filter_map(|ch| (ch as char).to_digit(radix)); - let overflow_error = if negative { - ParseIntValueError::NegOverflow - } else { - ParseIntValueError::PosOverflow - }; - for chunk in value.chunks_mut(bits_per_digit) { - if let Some(mut digit) = digits.next() { - let digit_bits = &mut digit.view_bits_mut::()[..chunk.len()]; - chunk.clone_from_bitslice(digit_bits); - digit_bits.fill(false); - if digit != 0 { - return Err(overflow_error); - } - } else { - break; - } - } - for digit in digits { - if digit != 0 { - return Err(overflow_error); - } - } - let negative_zero = if negative { - // negating a value happens in three regions: - // * the least-significant zeros, which are left as zeros - // * the least-significant one bit, which is left as a one bit - // * all the most-significant bits, which are inverted - // e.g.: - const { - let inp = 0b1010_1_000_u8; - let out = 0b0101_1_000_u8; - assert!(inp.wrapping_neg() == out); - }; - if let Some(first_one) = value.first_one() { - let most_significant_bits = &mut value[first_one + 1..]; - // modifies in-place despite using `Not::not` - let _ = Not::not(most_significant_bits); - false - } else { - true - } - } else { - false - }; - if !negative_zero && type_is_signed && negative != value[value.len() - 1] { - Err(overflow_error) - } else { - Ok(Arc::new(value)) - } - } -} - -fn deserialize_int_value<'de, D: Deserializer<'de>>( - deserializer: D, - type_is_signed: bool, - type_width: Option, -) -> Result, D::Error> { - struct IntValueVisitor { - type_is_signed: bool, - type_width: Option, - } - impl<'de> Visitor<'de> for IntValueVisitor { - type Value = Arc; - - fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(if self.type_is_signed { - "SIntValue" - } else { - "UIntValue" - })?; - if let Some(type_width) = self.type_width { - write!(f, "<{type_width}>")?; - } - Ok(()) - } - - fn visit_str(self, v: &str) -> Result { - parse_int_value(v, self.type_is_signed, self.type_width, true).map_err(E::custom) - } - - fn visit_bytes(self, v: &[u8]) -> Result { - match std::str::from_utf8(v) { - Ok(v) => self.visit_str(v), - Err(_) => Err(Error::invalid_value(serde::de::Unexpected::Bytes(v), &self)), - } - } - } - deserializer.deserialize_str(IntValueVisitor { - type_is_signed, - type_width, - }) -} - macro_rules! impl_int { ($pretty_name:ident, $name:ident, $generic_name:ident, $value:ident, $SIGNED:literal) => { #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -611,12 +263,6 @@ macro_rules! impl_int { } Expr::from_dyn_int(MemoizeBitsToExpr.get_cow(bits)) } - fn from_str_without_ty( - self, - s: &str, - ) -> Result::Err> { - parse_int_value(s, $SIGNED, Some(self.width()), false).map(Self::Value::new) - } } impl IntType for $name { @@ -641,7 +287,6 @@ macro_rules! impl_int { impl Type for $name { type BaseType = $pretty_name; type MaskType = Bool; - type SimValue = $value; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { Bool @@ -652,7 +297,7 @@ macro_rules! impl_int { #[track_caller] fn from_canonical(canonical_type: CanonicalType) -> Self { let CanonicalType::$pretty_name(retval) = canonical_type else { - panic!("expected {}", stringify!($pretty_name)); + panic!("expected {}", stringify!($name)); }; $name { width: Width::from_usize(retval.width), @@ -661,26 +306,6 @@ macro_rules! impl_int { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), self.width()); - $value::new(Arc::new(bits.to_bitvec())) - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), self.width()); - assert_eq!(value.width(), self.width()); - value.bits_mut().copy_from_bitslice(bits); - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), self.width()); - assert_eq!(value.width(), self.width()); - bits.copy_from_bitslice(value.bits()); - } - } - - impl Default for $name { - fn default() -> Self { - Self::TYPE - } } impl StaticType for $name { @@ -695,46 +320,6 @@ macro_rules! impl_int { const MASK_TYPE_PROPERTIES: TypeProperties = Bool::TYPE_PROPERTIES; } - impl Serialize for $name { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.canonical().serialize(serializer) - } - } - - impl<'de, Width: Size> Deserialize<'de> for $name { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let name = |width| -> String { - if let Some(width) = width { - format!("a {}<{width}>", stringify!($pretty_name)) - } else { - format!("a {}", stringify!($pretty_name)) - } - }; - match CanonicalType::deserialize(deserializer)? { - CanonicalType::$pretty_name(retval) => { - if let Some(width) = Width::try_from_usize(retval.width()) { - Ok($name { width }) - } else { - Err(Error::invalid_value( - serde::de::Unexpected::Other(&name(Some(retval.width()))), - &&*name(Width::KNOWN_VALUE), - )) - } - } - ty => Err(Error::invalid_value( - serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), - &&*name(Width::KNOWN_VALUE), - )), - } - } - } - #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] pub struct $generic_name; @@ -746,13 +331,13 @@ macro_rules! impl_int { } } - #[derive(Clone, Eq, Hash)] + #[derive(Clone, PartialEq, Eq, Hash)] pub struct $value { bits: Arc, _phantom: PhantomData, } - impl fmt::Display for $value { + impl fmt::Debug for $value { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let value = self.to_bigint(); let (sign, magnitude) = value.into_parts(); @@ -766,41 +351,9 @@ macro_rules! impl_int { } } - impl fmt::Debug for $value { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::Display::fmt(self, f) - } - } - - impl std::str::FromStr for $value { - type Err = ParseIntValueError; - - fn from_str(s: &str) -> Result { - parse_int_value(s, $SIGNED, Width::KNOWN_VALUE, true).map(Self::new) - } - } - - impl Serialize for $value { - fn serialize(&self, serializer: S) -> Result { - self.to_string().serialize(serializer) - } - } - - impl<'de, Width: Size> Deserialize<'de> for $value { - fn deserialize>(deserializer: D) -> Result { - deserialize_int_value(deserializer, $SIGNED, Width::KNOWN_VALUE).map(Self::new) - } - } - - impl PartialEq<$value> for $value { - fn eq(&self, other: &$value) -> bool { - self.to_bigint() == other.to_bigint() - } - } - - impl PartialOrd<$value> for $value { - fn partial_cmp(&self, other: &$value) -> Option { - Some(self.to_bigint().cmp(&other.to_bigint())) + impl PartialOrd for $value { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) } } @@ -848,9 +401,6 @@ macro_rules! impl_int { pub fn bits(&self) -> &Arc { &self.bits } - pub fn bits_mut(&mut self) -> &mut BitSlice { - Arc::::make_mut(&mut self.bits) - } } impl ToLiteralBits for $value { @@ -1033,13 +583,11 @@ pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed { + Ord + std::hash::Hash + fmt::Debug - + fmt::Display + Send + Sync + 'static + ToExpr - + Into - + std::str::FromStr; + + Into; fn width(self) -> usize; fn new(width: ::SizeType) -> Self; fn new_static() -> Self @@ -1112,12 +660,9 @@ pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed { bytes, bit_width, ))) } - fn from_str_without_ty(self, s: &str) -> Result::Err>; } -pub trait IntType: - BoolOrIntType::Dyn, Value: FromStr> -{ +pub trait IntType: BoolOrIntType::Dyn> { type Dyn: IntType; fn as_dyn_int(self) -> Self::Dyn { Self::new_dyn(self.width()) @@ -1157,7 +702,7 @@ pub trait IntType: } } -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct Bool; impl sealed::BoolOrIntTypeSealed for Bool {} @@ -1189,10 +734,6 @@ impl BoolOrIntType for Bool { assert_eq!(bits.len(), 1); bits[0] } - - fn from_str_without_ty(self, s: &str) -> Result::Err> { - FromStr::from_str(s) - } } impl Bool { @@ -1207,7 +748,6 @@ impl Bool { impl Type for Bool { type BaseType = Bool; type MaskType = Bool; - type SimValue = bool; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { Bool @@ -1225,18 +765,6 @@ impl Type for Bool { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), 1); - bits[0] - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), 1); - *value = bits[0]; - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), 1); - bits.set(0, *value); - } } impl StaticType for Bool { @@ -1283,104 +811,4 @@ mod tests { assert_eq!(SInt::for_value(3).width, 3); assert_eq!(SInt::for_value(4).width, 4); } - - #[test] - fn test_serde_round_trip() { - use serde_json::json; - #[track_caller] - fn check( - value: T, - expected: serde_json::Value, - ) { - assert_eq!(serde_json::to_value(&value).unwrap(), expected); - assert_eq!(value, T::deserialize(expected).unwrap()); - } - check(UInt[0], json! { { "UInt": { "width": 0 } } }); - check(UInt::<0>::TYPE, json! { { "UInt": { "width": 0 } } }); - check(UInt::<35>::TYPE, json! { { "UInt": { "width": 35 } } }); - check(SInt[0], json! { { "SInt": { "width": 0 } } }); - check(SInt::<0>::TYPE, json! { { "SInt": { "width": 0 } } }); - check(SInt::<35>::TYPE, json! { { "SInt": { "width": 35 } } }); - check(Bool, json! { "Bool" }); - check(UIntValue::from(0u8), json! { "0x0_u8" }); - check(SIntValue::from(-128i8), json! { "-0x80_i8" }); - check(UInt[3].from_int_wrapping(5), json! { "0x5_u3" }); - check(UInt[12].from_int_wrapping(0x1123), json! { "0x123_u12" }); - check(SInt[12].from_int_wrapping(0xFEE), json! { "-0x12_i12" }); - check(SInt[12].from_int_wrapping(0x7EE), json! { "0x7EE_i12" }); - } - - #[test] - fn test_deserialize() { - use serde_json::json; - #[track_caller] - fn check( - expected: Result, - input: serde_json::Value, - ) { - let mut error = String::new(); - let value = T::deserialize(input).map_err(|e| -> &str { - error = e.to_string(); - &error - }); - assert_eq!(value, expected); - } - check::>( - Err("invalid value: a UInt<2>, expected a UInt<0>"), - json! { { "UInt": { "width": 2 } } }, - ); - check::>( - Err("invalid value: a Bool, expected a UInt<0>"), - json! { "Bool" }, - ); - check::>( - Err("invalid value: a Bool, expected a SInt<0>"), - json! { "Bool" }, - ); - check::( - Err("invalid value: a Bool, expected a UInt"), - json! { "Bool" }, - ); - check::( - Err("invalid value: a Bool, expected a SInt"), - json! { "Bool" }, - ); - check::(Err("value too large to fit in type"), json! { "2_u1" }); - check::(Err("value too large to fit in type"), json! { "10_u1" }); - check::(Err("value too large to fit in type"), json! { "0x2_u1" }); - check::(Err("value too large to fit in type"), json! { "0b10_u1" }); - check::(Err("value too large to fit in type"), json! { "0o2_u1" }); - check::(Err("value too large to fit in type"), json! { "0o377_i8" }); - check::(Err("value too large to fit in type"), json! { "0o200_i8" }); - check(Ok(SInt[8].from_int_wrapping(i8::MAX)), json! { "0o177_i8" }); - check::(Err("value too small to fit in type"), json! { "-0o201_i8" }); - check::(Err("value too small to fit in type"), json! { "-0o377_i8" }); - check::(Err("value too small to fit in type"), json! { "-0o400_i8" }); - check::( - Err("value too small to fit in type"), - json! { "-0o4000_i8" }, - ); - check(Ok(UIntValue::from(0u8)), json! { "0_u8" }); - check(Ok(UIntValue::from(0u8)), json! { "0b0_u8" }); - check(Ok(UIntValue::from(0u8)), json! { "00_u8" }); - check(Ok(UIntValue::from(0u8)), json! { "0x0_u8" }); - check(Ok(UIntValue::from(0u8)), json! { "0o0_u8" }); - check(Ok(SIntValue::from(-128i8)), json! { "-0x000_80_i8" }); - check(Ok(SIntValue::from(-128i8)), json! { "-0o002_00_hdl_i8" }); - check(Ok(SIntValue::from(-128i8)), json! { "-0b1__000_0000_i8" }); - check(Ok(UInt[3].from_int_wrapping(5)), json! { " + 0x5_u3 " }); - check( - Ok(UInt[12].from_int_wrapping(0x1123)), - json! { "0x1_2_3_hdl_u12" }, - ); - check(Ok(SInt[12].from_int_wrapping(0xFEE)), json! { "-0x12_i12" }); - check( - Ok(SInt[12].from_int_wrapping(0x7EE)), - json! { " + \t0x7__E_e_i012\n" }, - ); - check(Ok(SInt[0].from_int_wrapping(0)), json! { "-0i0" }); - check(Ok(SInt[1].from_int_wrapping(0)), json! { "-0i1" }); - check(Ok(SInt[0].from_int_wrapping(0)), json! { "-0x0i0" }); - check(Ok(SInt[1].from_int_wrapping(0)), json! { "-0x0i1" }); - } } diff --git a/crates/fayalite/src/lib.rs b/crates/fayalite/src/lib.rs index 932464b..512572d 100644 --- a/crates/fayalite/src/lib.rs +++ b/crates/fayalite/src/lib.rs @@ -76,8 +76,6 @@ pub use fayalite_proc_macros::hdl_module; #[doc(inline)] pub use fayalite_proc_macros::hdl; -pub use bitvec; - /// struct used as a placeholder when applying defaults #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] pub struct __; diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs index d2e94d9..dd6cff6 100644 --- a/crates/fayalite/src/phantom_const.rs +++ b/crates/fayalite/src/phantom_const.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information +use serde::{de::DeserializeOwned, Deserialize, Serialize}; + use crate::{ expr::{ ops::{ExprPartialEq, ExprPartialOrd}, @@ -8,25 +10,14 @@ use crate::{ }, int::Bool, intern::{Intern, Interned, InternedCompare, LazyInterned, Memoize}, - sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, - ty::{ - impl_match_variant_as_self, - serde_impls::{SerdeCanonicalType, SerdePhantomConst}, - CanonicalType, StaticType, Type, TypeProperties, - }, -}; -use bitvec::slice::BitSlice; -use serde::{ - de::{DeserializeOwned, Error}, - Deserialize, Deserializer, Serialize, Serializer, + ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; use std::{ any::Any, fmt, hash::{Hash, Hasher}, marker::PhantomData, - ops::Index, }; #[derive(Clone)] @@ -122,20 +113,6 @@ pub struct PhantomConst, } -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] -pub struct PhantomConstWithoutGenerics; - -#[allow(non_upper_case_globals)] -pub const PhantomConst: PhantomConstWithoutGenerics = PhantomConstWithoutGenerics; - -impl Index for PhantomConstWithoutGenerics { - type Output = PhantomConst; - - fn index(&self, value: T) -> &Self::Output { - Interned::into_inner(PhantomConst::new(value.intern()).intern_sized()) - } -} - impl fmt::Debug for PhantomConst { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("PhantomConst").field(&self.get()).finish() @@ -222,6 +199,17 @@ impl Memoize for PhantomConstCanonicalMemoize PhantomConst +where + Interned: Default, +{ + pub const fn default() -> Self { + PhantomConst { + value: LazyInterned::new_lazy(&Interned::::default), + } + } +} + impl PhantomConst { pub fn new(value: Interned) -> Self { Self { @@ -258,7 +246,6 @@ impl PhantomConst { impl Type for PhantomConst { type BaseType = PhantomConst; type MaskType = (); - type SimValue = PhantomConst; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { @@ -279,70 +266,18 @@ impl Type for PhantomConst { fn source_location() -> SourceLocation { SourceLocation::builtin() } - - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert!(bits.is_empty()); - *self - } - - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert!(bits.is_empty()); - assert_eq!(*value, *self); - } - - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert!(bits.is_empty()); - assert_eq!(*value, *self); - } -} - -impl Default for PhantomConst -where - Interned: Default, -{ - fn default() -> Self { - Self::TYPE - } } impl StaticType for PhantomConst where Interned: Default, { - const TYPE: Self = PhantomConst { - value: LazyInterned::new_lazy(&Interned::::default), - }; + const TYPE: Self = Self::default(); const MASK_TYPE: Self::MaskType = (); const TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES; const MASK_TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES; } -type SerdeType = SerdeCanonicalType>>; - -impl Serialize for PhantomConst { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - SerdeType::::PhantomConst(SerdePhantomConst(self.get())).serialize(serializer) - } -} - -impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for PhantomConst { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - match SerdeType::::deserialize(deserializer)? { - SerdeCanonicalType::PhantomConst(SerdePhantomConst(value)) => Ok(Self::new(value)), - ty => Err(Error::invalid_value( - serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), - &"a PhantomConst", - )), - } - } -} - impl ExprPartialEq for PhantomConst { fn cmp_eq(lhs: Expr, rhs: Expr) -> Expr { assert_eq!(Expr::ty(lhs), Expr::ty(rhs)); @@ -376,30 +311,3 @@ impl ExprPartialOrd for PhantomConst { true.to_expr() } } - -impl SimValuePartialEq for PhantomConst { - fn sim_value_eq(this: &SimValue, other: &SimValue) -> bool { - assert_eq!(SimValue::ty(this), SimValue::ty(other)); - true - } -} - -impl ToSimValue for PhantomConst { - type Type = PhantomConst; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_value(*self, *self) - } -} - -impl ToSimValueWithType> for PhantomConst { - fn to_sim_value_with_type(&self, ty: PhantomConst) -> SimValue> { - SimValue::from_value(ty, *self) - } -} - -impl ToSimValueWithType for PhantomConst { - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_value(Self::from_canonical(ty), *self)) - } -} diff --git a/crates/fayalite/src/prelude.rs b/crates/fayalite/src/prelude.rs index 519210f..39fa143 100644 --- a/crates/fayalite/src/prelude.rs +++ b/crates/fayalite/src/prelude.rs @@ -20,7 +20,7 @@ pub use crate::{ hdl_cover_with_enable, MakeFormalExpr, }, hdl, hdl_module, - int::{Bool, DynSize, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue}, + int::{Bool, DynSize, KnownSize, SInt, SIntType, Size, UInt, UIntType}, memory::{Mem, MemBuilder, ReadUnderWrite}, module::{ annotate, connect, connect_any, incomplete_wire, instance, memory, memory_array, @@ -29,15 +29,9 @@ pub use crate::{ phantom_const::PhantomConst, reg::Reg, reset::{AsyncReset, Reset, SyncReset, ToAsyncReset, ToReset, ToSyncReset}, - sim::{ - time::{SimDuration, SimInstant}, - value::{SimValue, ToSimValue, ToSimValueWithType}, - ExternModuleSimulationState, Simulation, - }, source_location::SourceLocation, ty::{AsMask, CanonicalType, Type}, util::{ConstUsize, GenericConstUsize}, wire::Wire, __, }; -pub use bitvec::{slice::BitSlice, vec::BitVec}; diff --git a/crates/fayalite/src/reset.rs b/crates/fayalite/src/reset.rs index 312a8ea..9328365 100644 --- a/crates/fayalite/src/reset.rs +++ b/crates/fayalite/src/reset.rs @@ -7,7 +7,6 @@ use crate::{ source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; -use bitvec::slice::BitSlice; mod sealed { pub trait ResetTypeSealed {} @@ -46,7 +45,6 @@ macro_rules! reset_type { impl Type for $name { type BaseType = $name; type MaskType = Bool; - type SimValue = bool; impl_match_variant_as_self!(); @@ -68,21 +66,6 @@ macro_rules! reset_type { }; retval } - - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), 1); - bits[0] - } - - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), 1); - *value = bits[0]; - } - - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), 1); - bits.set(0, *value); - } } impl $name { diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs index 563cd37..275b106 100644 --- a/crates/fayalite/src/sim.rs +++ b/crates/fayalite/src/sim.rs @@ -14,7 +14,7 @@ use crate::{ }, ExprEnum, Flow, ToLiteralBits, }, - int::{BoolOrIntType, UIntValue}, + int::{BoolOrIntType, IntType, SIntValue, UIntValue}, intern::{ Intern, Interned, InternedCompare, Memoize, PtrEqWithTypeId, SupportsPtrEqWithTypeId, }, @@ -38,7 +38,6 @@ use crate::{ TypeIndexRange, TypeLayout, TypeLen, TypeParts, }, time::{SimDuration, SimInstant}, - value::SimValue, }, ty::StaticType, util::{BitSliceWriteWithBase, DebugAsDisplay}, @@ -73,7 +72,6 @@ use std::{ mod interpreter; pub mod time; -pub mod value; pub mod vcd; #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)] @@ -5906,6 +5904,635 @@ impl SimTraceKind { } } +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct SimValue { + ty: T, + bits: BitVec, +} + +impl fmt::Debug for SimValue { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("SimValue") + .field("ty", &self.ty) + .field("bits", &BitSliceWriteWithBase(&self.bits)) + .finish() + } +} + +impl SimValue { + #[track_caller] + fn to_expr_impl(ty: CanonicalType, bits: &BitSlice) -> Expr { + match ty { + CanonicalType::UInt(_) => Expr::canonical(::bits_to_expr(Cow::Borrowed(bits))), + CanonicalType::SInt(_) => Expr::canonical(::bits_to_expr(Cow::Borrowed(bits))), + CanonicalType::Bool(_) => Expr::canonical(Bool::bits_to_expr(Cow::Borrowed(bits))), + CanonicalType::Array(ty) => { + let element_bit_width = ty.element().bit_width(); + Expr::::canonical( + crate::expr::ops::ArrayLiteral::new( + ty.element(), + (0..ty.len()) + .map(|array_index| { + let start = element_bit_width * array_index; + let end = start + element_bit_width; + Self::to_expr_impl(ty.element(), &bits[start..end]) + }) + .collect(), + ) + .to_expr(), + ) + } + CanonicalType::Enum(ty) => { + let discriminant_bit_width = ty.discriminant_bit_width(); + let mut variant_index = [0; mem::size_of::()]; + variant_index.view_bits_mut::()[0..discriminant_bit_width] + .clone_from_bitslice(&bits[..discriminant_bit_width]); + let variant_index = usize::from_le_bytes(variant_index); + if let Some(variant) = ty.variants().get(variant_index) { + let data_bit_width = variant.ty.map_or(0, CanonicalType::bit_width); + Expr::canonical( + crate::expr::ops::EnumLiteral::new_by_index( + ty, + variant_index, + variant.ty.map(|ty| { + Self::to_expr_impl( + ty, + &bits[discriminant_bit_width + ..discriminant_bit_width + data_bit_width], + ) + }), + ) + .to_expr(), + ) + } else { + Expr::canonical(::bits_to_expr(Cow::Borrowed(bits)).cast_bits_to(ty)) + } + } + CanonicalType::Bundle(ty) => Expr::canonical( + crate::expr::ops::BundleLiteral::new( + ty, + ty.fields() + .iter() + .zip(ty.field_offsets().iter()) + .map(|(field, &field_offset)| { + Self::to_expr_impl( + field.ty, + &bits[field_offset..field_offset + field.ty.bit_width()], + ) + }) + .collect(), + ) + .to_expr(), + ), + CanonicalType::AsyncReset(ty) => { + Expr::canonical(Bool::bits_to_expr(Cow::Borrowed(bits)).cast_to(ty)) + } + CanonicalType::SyncReset(ty) => { + Expr::canonical(Bool::bits_to_expr(Cow::Borrowed(bits)).cast_to(ty)) + } + CanonicalType::Reset(_) => panic!( + "can't convert SimValue to Expr -- \ + can't deduce whether reset value should be sync or async" + ), + CanonicalType::Clock(ty) => { + Expr::canonical(Bool::bits_to_expr(Cow::Borrowed(bits)).cast_to(ty)) + } + CanonicalType::PhantomConst(ty) => Expr::canonical(ty.to_expr()), + } + } +} + +impl ToExpr for SimValue { + type Type = T; + + #[track_caller] + fn to_expr(&self) -> Expr { + Expr::from_canonical(SimValue::to_expr_impl(self.ty.canonical(), &self.bits)) + } +} + +impl ToSimValue for SimValue { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + assert_eq!(self.ty, ty); + self.clone() + } + + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue { + assert_eq!(self.ty, ty); + self + } + + #[track_caller] + fn box_into_sim_value(self: Box, ty: T) -> SimValue { + assert_eq!(self.ty, ty); + *self + } +} + +impl ToSimValue for BitVec { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + self.clone().into_sim_value(ty) + } + + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue { + assert_eq!(ty.canonical().bit_width(), self.len()); + SimValue { ty, bits: self } + } + + #[track_caller] + fn box_into_sim_value(self: Box, ty: T) -> SimValue { + Self::into_sim_value(*self, ty) + } +} + +impl ToSimValue for bitvec::boxed::BitBox { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + self.clone().into_sim_value(ty) + } + + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue { + assert_eq!(ty.canonical().bit_width(), self.len()); + SimValue { + ty, + bits: self.into_bitvec(), + } + } + + #[track_caller] + fn box_into_sim_value(self: Box, ty: T) -> SimValue { + Self::into_sim_value(*self, ty) + } +} + +impl ToSimValue for BitSlice { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + assert_eq!(ty.canonical().bit_width(), self.len()); + SimValue { + ty, + bits: self.to_bitvec(), + } + } +} + +impl SimValue { + pub fn ty(&self) -> T { + self.ty + } + pub fn bits(&self) -> &BitSlice { + &self.bits + } + pub fn into_bits(self) -> BitVec { + self.bits + } + #[track_caller] + pub fn from_canonical(v: SimValue) -> Self { + Self { + ty: T::from_canonical(v.ty), + bits: v.bits, + } + } + pub fn into_canonical(self) -> SimValue { + SimValue { + ty: self.ty.canonical(), + bits: self.bits, + } + } + #[track_caller] + pub fn from_dyn_int(v: SimValue) -> Self + where + T: IntType, + { + Self { + ty: T::from_dyn_int(v.ty), + bits: v.bits, + } + } + pub fn into_dyn_int(self) -> SimValue + where + T: IntType, + { + SimValue { + ty: self.ty.as_dyn_int(), + bits: self.bits, + } + } + #[track_caller] + pub fn from_bundle(v: SimValue) -> Self + where + T: BundleType, + { + Self { + ty: T::from_canonical(CanonicalType::Bundle(v.ty)), + bits: v.bits, + } + } + pub fn into_bundle(self) -> SimValue + where + T: BundleType, + { + SimValue { + ty: Bundle::from_canonical(self.ty.canonical()), + bits: self.bits, + } + } + #[track_caller] + pub fn from_enum(v: SimValue) -> Self + where + T: EnumType, + { + Self { + ty: T::from_canonical(CanonicalType::Enum(v.ty)), + bits: v.bits, + } + } + pub fn into_enum(self) -> SimValue + where + T: EnumType, + { + SimValue { + ty: Enum::from_canonical(self.ty.canonical()), + bits: self.bits, + } + } +} + +pub trait ToSimValue { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue; + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue + where + Self: Sized, + { + self.to_sim_value(ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: T) -> SimValue { + self.to_sim_value(ty) + } +} + +impl, T: Type> ToSimValue for &'_ This { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl, T: Type> ToSimValue for &'_ mut This { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl, T: Type> ToSimValue for Box { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue { + This::box_into_sim_value(self, ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: T) -> SimValue { + This::box_into_sim_value(*self, ty) + } +} + +impl + Send + Sync + 'static, T: Type> ToSimValue + for Interned +{ + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl SimValue> { + #[track_caller] + pub fn from_array_elements< + I: IntoIterator, IntoIter: ExactSizeIterator>, + >( + elements: I, + ty: ArrayType, + ) -> Self { + let mut iter = elements.into_iter(); + assert_eq!(iter.len(), ty.len()); + let Some(first) = iter.next() else { + return SimValue { + ty, + bits: BitVec::new(), + }; + }; + let SimValue { + ty: element_ty, + mut bits, + } = first.into_sim_value(ty.element()); + assert_eq!(element_ty, ty.element()); + bits.reserve(ty.type_properties().bit_width - bits.len()); + for element in iter { + let SimValue { + ty: element_ty, + bits: element_bits, + } = element.into_sim_value(ty.element()); + assert_eq!(element_ty, ty.element()); + bits.extend_from_bitslice(&element_bits); + } + SimValue { ty, bits } + } +} + +impl, T: Type> ToSimValue> for [Element] { + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } +} + +impl> ToSimValue for [Element] { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } +} + +impl, T: Type, const N: usize> ToSimValue> for [Element; N] +where + ConstUsize: KnownSize, +{ + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: Array) -> SimValue> { + SimValue::from_array_elements( as From>>::from(self), ty) + } +} + +impl, T: Type, const N: usize> ToSimValue> for [Element; N] +where + ConstUsize: KnownSize, +{ + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: Array) -> SimValue> { + SimValue::from_array_elements( as From>>::from(self), ty) + } +} + +impl, const N: usize> ToSimValue + for [Element; N] +{ + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements( + as From>>::from(self), + ::from_canonical(ty), + ) + .into_canonical() + } +} + +impl, T: Type> ToSimValue> for Vec { + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(self, ty) + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: Array) -> SimValue> { + SimValue::from_array_elements(*self, ty) + } +} + +impl> ToSimValue for Vec { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(self, ::from_canonical(ty)).into_canonical() + } + #[track_caller] + fn box_into_sim_value(self: Box, ty: CanonicalType) -> SimValue { + SimValue::from_array_elements(*self, ::from_canonical(ty)).into_canonical() + } +} + +impl ToSimValue for Expr { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + assert_eq!(Expr::ty(*self), ty); + SimValue { + ty, + bits: self + .to_literal_bits() + .expect("must be a literal expression") + .to_bitvec(), + } + } +} + +macro_rules! impl_to_sim_value_for_bool_like { + ($ty:ident) => { + impl ToSimValue<$ty> for bool { + fn to_sim_value(&self, ty: $ty) -> SimValue<$ty> { + SimValue { + ty, + bits: BitVec::repeat(*self, 1), + } + } + } + }; +} + +impl_to_sim_value_for_bool_like!(Bool); +impl_to_sim_value_for_bool_like!(AsyncReset); +impl_to_sim_value_for_bool_like!(SyncReset); +impl_to_sim_value_for_bool_like!(Reset); +impl_to_sim_value_for_bool_like!(Clock); + +impl ToSimValue for bool { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + match ty { + CanonicalType::UInt(_) + | CanonicalType::SInt(_) + | CanonicalType::Array(_) + | CanonicalType::Enum(_) + | CanonicalType::Bundle(_) + | CanonicalType::PhantomConst(_) => { + panic!("can't create SimValue from bool: expected value of type: {ty:?}"); + } + CanonicalType::Bool(_) + | CanonicalType::AsyncReset(_) + | CanonicalType::SyncReset(_) + | CanonicalType::Reset(_) + | CanonicalType::Clock(_) => SimValue { + ty, + bits: BitVec::repeat(*self, 1), + }, + } + } +} + +macro_rules! impl_to_sim_value_for_primitive_int { + ($prim:ident) => { + impl ToSimValue<<$prim as ToExpr>::Type> for $prim { + #[track_caller] + fn to_sim_value( + &self, + ty: <$prim as ToExpr>::Type, + ) -> SimValue<<$prim as ToExpr>::Type> { + SimValue { + ty, + bits: <<$prim as ToExpr>::Type as BoolOrIntType>::le_bytes_to_bits_wrapping( + &self.to_le_bytes(), + ty.width(), + ), + } + } + } + + impl ToSimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { + #[track_caller] + fn to_sim_value( + &self, + ty: <<$prim as ToExpr>::Type as IntType>::Dyn, + ) -> SimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> { + SimValue { + ty, + bits: <<$prim as ToExpr>::Type as BoolOrIntType>::le_bytes_to_bits_wrapping( + &self.to_le_bytes(), + ty.width(), + ), + } + } + } + + impl ToSimValue for $prim { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + let ty: <<$prim as ToExpr>::Type as IntType>::Dyn = Type::from_canonical(ty); + self.to_sim_value(ty).into_canonical() + } + } + }; +} + +impl_to_sim_value_for_primitive_int!(u8); +impl_to_sim_value_for_primitive_int!(u16); +impl_to_sim_value_for_primitive_int!(u32); +impl_to_sim_value_for_primitive_int!(u64); +impl_to_sim_value_for_primitive_int!(u128); +impl_to_sim_value_for_primitive_int!(usize); +impl_to_sim_value_for_primitive_int!(i8); +impl_to_sim_value_for_primitive_int!(i16); +impl_to_sim_value_for_primitive_int!(i32); +impl_to_sim_value_for_primitive_int!(i64); +impl_to_sim_value_for_primitive_int!(i128); +impl_to_sim_value_for_primitive_int!(isize); + +macro_rules! impl_to_sim_value_for_int_value { + ($IntValue:ident, $Int:ident, $IntType:ident) => { + impl ToSimValue<$IntType> for $IntValue { + fn to_sim_value(&self, ty: $IntType) -> SimValue<$IntType> { + self.bits().to_bitvec().into_sim_value(ty) + } + + fn into_sim_value(self, ty: $IntType) -> SimValue<$IntType> { + Arc::try_unwrap(self.into_bits()) + .unwrap_or_else(|v: Arc| v.to_bitvec()) + .into_sim_value(ty) + } + + fn box_into_sim_value( + self: Box, + ty: $IntType, + ) -> SimValue<$IntType> { + Self::into_sim_value(*self, ty) + } + } + + impl ToSimValue<$Int> for $IntValue { + fn to_sim_value(&self, ty: $Int) -> SimValue<$Int> { + self.bits().to_bitvec().into_sim_value(ty) + } + + fn into_sim_value(self, ty: $Int) -> SimValue<$Int> { + Arc::try_unwrap(self.into_bits()) + .unwrap_or_else(|v: Arc| v.to_bitvec()) + .into_sim_value(ty) + } + + fn box_into_sim_value(self: Box, ty: $Int) -> SimValue<$Int> { + Self::into_sim_value(*self, ty) + } + } + + impl ToSimValue for $IntValue { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + ToSimValue::<$Int>::to_sim_value(self, $Int::from_canonical(ty)).into_canonical() + } + + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + ToSimValue::<$Int>::into_sim_value(self, $Int::from_canonical(ty)).into_canonical() + } + + #[track_caller] + fn box_into_sim_value(self: Box, ty: CanonicalType) -> SimValue { + Self::into_sim_value(*self, ty) + } + } + }; +} + +impl_to_sim_value_for_int_value!(UIntValue, UInt, UIntType); +impl_to_sim_value_for_int_value!(SIntValue, SInt, SIntType); + #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] enum MaybeNeedsSettle { NeedsSettle(S), @@ -6071,11 +6698,6 @@ impl SimulationModuleState { mut target: Target, which_module: WhichModule, ) -> CompiledValue { - assert!( - target.canonical_ty().is_passive(), - "simulator read/write expression must have a passive type \ - (recursively contains no fields with `#[hdl(flip)]`)" - ); if let Some(&retval) = self.io_targets.get(&target) { return retval; } @@ -6397,19 +7019,19 @@ impl MaybeNeedsSettleFn<&'_ mut interpreter::State> for ReadBo struct ReadFn { compiled_value: CompiledValue, io: Expr, + bits: BitVec, } impl MaybeNeedsSettleFn<&'_ mut interpreter::State> for ReadFn { type Output = SimValue; fn call(self, state: &mut interpreter::State) -> Self::Output { - let Self { compiled_value, io } = self; - SimulationImpl::read_no_settle_helper( - state, - io, + let Self { compiled_value, - UIntValue::new(Arc::new(BitVec::repeat(false, Expr::ty(io).bit_width()))), - ) + io, + bits, + } = self; + SimulationImpl::read_no_settle_helper(state, io, compiled_value, bits) } } @@ -6763,7 +7385,7 @@ impl SimulationImpl { (WaitTarget::Instant(instant), None) => Some(instant), (WaitTarget::Instant(instant), Some(retval)) => Some(instant.min(retval)), (WaitTarget::Change { key, value }, retval) => { - if Self::value_changed(&mut self.state, key, SimValue::bits(value).bits()) { + if Self::value_changed(&mut self.state, key, &value.bits) { Some(self.instant) } else { retval @@ -7061,7 +7683,7 @@ impl SimulationImpl { } } #[track_caller] - fn read_write_sim_value_helper( + fn read_write_sim_value_helper( state: &mut interpreter::State, compiled_value: CompiledValue, start_bit_index: usize, @@ -7156,13 +7778,15 @@ impl SimulationImpl { state: &mut interpreter::State, io: Expr, compiled_value: CompiledValue, - mut bits: UIntValue, + mut bits: BitVec, ) -> SimValue { + bits.clear(); + bits.resize(compiled_value.layout.ty.bit_width(), false); SimulationImpl::read_write_sim_value_helper( state, compiled_value, 0, - bits.bits_mut(), + &mut bits, |_signed, bit_range, bits, value| { ::copy_bits_from_bigint_wrapping(value, &mut bits[bit_range]); }, @@ -7173,7 +7797,10 @@ impl SimulationImpl { bits[bit_range].clone_from_bitslice(bitslice); }, ); - SimValue::from_bits(Expr::ty(io), bits) + SimValue { + ty: Expr::ty(io), + bits, + } } /// doesn't modify `bits` fn value_changed( @@ -7215,7 +7842,11 @@ impl SimulationImpl { ) { let compiled_value = self.get_module(which_module).read_helper(io, which_module); let value = compiled_value - .map(|compiled_value| ReadFn { compiled_value, io }) + .map(|compiled_value| ReadFn { + compiled_value, + io, + bits: BitVec::new(), + }) .apply_no_settle(&mut self.state); let (MaybeNeedsSettle::NeedsSettle(compiled_value) | MaybeNeedsSettle::NoSettleNeeded(compiled_value)) = compiled_value; @@ -7232,12 +7863,12 @@ impl SimulationImpl { .get_module_mut(which_module) .write_helper(io, which_module); self.state_ready_to_run = true; - assert_eq!(Expr::ty(io), SimValue::ty(value)); + assert_eq!(Expr::ty(io), value.ty()); Self::read_write_sim_value_helper( &mut self.state, compiled_value, 0, - &mut value.bits().bits(), + &mut value.bits(), |signed, bit_range, bits, value| { if signed { *value = SInt::bits_to_bigint(&bits[bit_range]); @@ -7531,10 +8162,10 @@ macro_rules! impl_simulation_methods { SimValue::from_canonical($self.settle_if_needed(retval)$(.$await)?) } $(#[$track_caller])? - pub $($async)? fn write>(&mut $self, io: Expr, value: V) { + pub $($async)? fn write>(&mut $self, io: Expr, value: V) { $self.sim_impl.borrow_mut().write( Expr::canonical(io), - &SimValue::into_canonical(value.into_sim_value_with_type(Expr::ty(io))), + &value.into_sim_value(Expr::ty(io)).into_canonical(), $which_module, ); } diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs deleted file mode 100644 index 737043a..0000000 --- a/crates/fayalite/src/sim/value.rs +++ /dev/null @@ -1,913 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// See Notices.txt for copyright information - -use crate::{ - array::{Array, ArrayType}, - bundle::{Bundle, BundleType}, - clock::Clock, - enum_::{Enum, EnumType}, - expr::{CastBitsTo, Expr, ToExpr}, - int::{Bool, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue}, - reset::{AsyncReset, Reset, SyncReset}, - ty::{CanonicalType, StaticType, Type}, - util::{ - alternating_cell::{AlternatingCell, AlternatingCellMethods}, - ConstUsize, - }, -}; -use bitvec::{slice::BitSlice, vec::BitVec}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use std::{ - fmt, - ops::{Deref, DerefMut}, - sync::Arc, -}; - -#[derive(Copy, Clone, Eq, PartialEq)] -enum ValidFlags { - BothValid = 0, - OnlyValueValid = 1, - OnlyBitsValid = 2, -} - -#[derive(Clone)] -struct SimValueInner { - value: T::SimValue, - bits: UIntValue, - valid_flags: ValidFlags, - ty: T, -} - -impl SimValueInner { - fn fill_bits(&mut self) { - match self.valid_flags { - ValidFlags::BothValid | ValidFlags::OnlyBitsValid => {} - ValidFlags::OnlyValueValid => { - self.ty.sim_value_to_bits(&self.value, self.bits.bits_mut()); - self.valid_flags = ValidFlags::BothValid; - } - } - } - fn into_bits(mut self) -> UIntValue { - self.fill_bits(); - self.bits - } - fn bits_mut(&mut self) -> &mut UIntValue { - self.fill_bits(); - self.valid_flags = ValidFlags::OnlyBitsValid; - &mut self.bits - } - fn fill_value(&mut self) { - match self.valid_flags { - ValidFlags::BothValid | ValidFlags::OnlyValueValid => {} - ValidFlags::OnlyBitsValid => { - self.ty - .sim_value_clone_from_bits(&mut self.value, self.bits.bits()); - self.valid_flags = ValidFlags::BothValid; - } - } - } - fn into_value(mut self) -> T::SimValue { - self.fill_value(); - self.value - } - fn value_mut(&mut self) -> &mut T::SimValue { - self.fill_value(); - self.valid_flags = ValidFlags::OnlyValueValid; - &mut self.value - } -} - -impl AlternatingCellMethods for SimValueInner { - fn unique_to_shared(&mut self) { - match self.valid_flags { - ValidFlags::BothValid => return, - ValidFlags::OnlyValueValid => { - self.ty.sim_value_to_bits(&self.value, self.bits.bits_mut()) - } - ValidFlags::OnlyBitsValid => self - .ty - .sim_value_clone_from_bits(&mut self.value, self.bits.bits()), - } - self.valid_flags = ValidFlags::BothValid; - } - - fn shared_to_unique(&mut self) {} -} - -#[derive(Serialize, Deserialize)] -#[serde(rename = "SimValue")] -#[serde(bound( - serialize = "T: Type + Serialize", - deserialize = "T: Type> + Deserialize<'de>" -))] -struct SerdeSimValue<'a, T: Type> { - ty: T, - value: std::borrow::Cow<'a, T::SimValue>, -} - -impl + Serialize> Serialize for SimValue { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - SerdeSimValue { - ty: SimValue::ty(self), - value: std::borrow::Cow::Borrowed(&*self), - } - .serialize(serializer) - } -} - -impl<'de, T: Type> + Deserialize<'de>> Deserialize<'de> for SimValue { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let SerdeSimValue { ty, value } = SerdeSimValue::::deserialize(deserializer)?; - Ok(SimValue::from_value(ty, value.into_owned())) - } -} - -pub struct SimValue { - inner: AlternatingCell>, -} - -impl Clone for SimValue { - fn clone(&self) -> Self { - Self { - inner: AlternatingCell::new_unique(self.inner.share().clone()), - } - } -} - -impl SimValue { - #[track_caller] - pub fn from_bits(ty: T, bits: UIntValue) -> Self { - assert_eq!(ty.canonical().bit_width(), bits.width()); - let inner = SimValueInner { - value: ty.sim_value_from_bits(bits.bits()), - bits, - valid_flags: ValidFlags::BothValid, - ty, - }; - Self { - inner: AlternatingCell::new_shared(inner), - } - } - #[track_caller] - pub fn from_bitslice(ty: T, bits: &BitSlice) -> Self { - Self::from_bits(ty, UIntValue::new(Arc::new(bits.to_bitvec()))) - } - pub fn from_value(ty: T, value: T::SimValue) -> Self { - let inner = SimValueInner { - bits: UIntValue::new_dyn(Arc::new(BitVec::repeat(false, ty.canonical().bit_width()))), - value, - valid_flags: ValidFlags::OnlyValueValid, - ty, - }; - Self { - inner: AlternatingCell::new_unique(inner), - } - } - pub fn ty(this: &Self) -> T { - this.inner.share().ty - } - pub fn into_bits(this: Self) -> UIntValue { - this.inner.into_inner().into_bits() - } - pub fn into_ty_and_bits(this: Self) -> (T, UIntValue) { - let inner = this.inner.into_inner(); - (inner.ty, inner.into_bits()) - } - pub fn bits(this: &Self) -> &UIntValue { - &this.inner.share().bits - } - pub fn bits_mut(this: &mut Self) -> &mut UIntValue { - this.inner.unique().bits_mut() - } - pub fn into_value(this: Self) -> T::SimValue { - this.inner.into_inner().into_value() - } - pub fn value(this: &Self) -> &T::SimValue { - &this.inner.share().value - } - pub fn value_mut(this: &mut Self) -> &mut T::SimValue { - this.inner.unique().value_mut() - } - #[track_caller] - pub fn from_canonical(v: SimValue) -> Self { - let (ty, bits) = SimValue::into_ty_and_bits(v); - Self::from_bits(T::from_canonical(ty), bits) - } - pub fn into_canonical(this: Self) -> SimValue { - let (ty, bits) = Self::into_ty_and_bits(this); - SimValue::from_bits(ty.canonical(), bits) - } - pub fn canonical(this: &Self) -> SimValue { - SimValue::from_bits(Self::ty(this).canonical(), Self::bits(this).clone()) - } - #[track_caller] - pub fn from_dyn_int(v: SimValue) -> Self - where - T: IntType, - { - let (ty, bits) = SimValue::into_ty_and_bits(v); - SimValue::from_bits(T::from_dyn_int(ty), bits) - } - pub fn into_dyn_int(this: Self) -> SimValue - where - T: IntType, - { - let (ty, bits) = Self::into_ty_and_bits(this); - SimValue::from_bits(ty.as_dyn_int(), bits) - } - pub fn to_dyn_int(this: &Self) -> SimValue - where - T: IntType, - { - SimValue::from_bits(Self::ty(this).as_dyn_int(), Self::bits(&this).clone()) - } - #[track_caller] - pub fn from_bundle(v: SimValue) -> Self - where - T: BundleType, - { - let (ty, bits) = SimValue::into_ty_and_bits(v); - SimValue::from_bits(T::from_canonical(CanonicalType::Bundle(ty)), bits) - } - pub fn into_bundle(this: Self) -> SimValue - where - T: BundleType, - { - let (ty, bits) = Self::into_ty_and_bits(this); - SimValue::from_bits(Bundle::from_canonical(ty.canonical()), bits) - } - pub fn to_bundle(this: &Self) -> SimValue - where - T: BundleType, - { - SimValue::from_bits( - Bundle::from_canonical(Self::ty(this).canonical()), - Self::bits(&this).clone(), - ) - } - #[track_caller] - pub fn from_enum(v: SimValue) -> Self - where - T: EnumType, - { - let (ty, bits) = SimValue::into_ty_and_bits(v); - SimValue::from_bits(T::from_canonical(CanonicalType::Enum(ty)), bits) - } - pub fn into_enum(this: Self) -> SimValue - where - T: EnumType, - { - let (ty, bits) = Self::into_ty_and_bits(this); - SimValue::from_bits(Enum::from_canonical(ty.canonical()), bits) - } - pub fn to_enum(this: &Self) -> SimValue - where - T: EnumType, - { - SimValue::from_bits( - Enum::from_canonical(Self::ty(this).canonical()), - Self::bits(&this).clone(), - ) - } -} - -impl Deref for SimValue { - type Target = T::SimValue; - - fn deref(&self) -> &Self::Target { - Self::value(self) - } -} - -impl DerefMut for SimValue { - fn deref_mut(&mut self) -> &mut Self::Target { - Self::value_mut(self) - } -} - -impl fmt::Debug for SimValue { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let inner = self.inner.share(); - f.debug_struct("SimValue") - .field("ty", &inner.ty) - .field("value", &inner.value) - .finish() - } -} - -impl ToExpr for SimValue { - type Type = T; - - #[track_caller] - fn to_expr(&self) -> Expr { - let inner = self.inner.share(); - inner.bits.cast_bits_to(inner.ty) - } -} - -pub trait SimValuePartialEq: Type { - #[track_caller] - fn sim_value_eq(this: &SimValue, other: &SimValue) -> bool; -} - -impl, U: Type> PartialEq> for SimValue { - #[track_caller] - fn eq(&self, other: &SimValue) -> bool { - T::sim_value_eq(self, other) - } -} - -impl SimValuePartialEq> for UIntType { - fn sim_value_eq(this: &SimValue, other: &SimValue>) -> bool { - **this == **other - } -} - -impl SimValuePartialEq> for SIntType { - fn sim_value_eq(this: &SimValue, other: &SimValue>) -> bool { - **this == **other - } -} - -impl SimValuePartialEq for Bool { - fn sim_value_eq(this: &SimValue, other: &SimValue) -> bool { - **this == **other - } -} - -pub trait ToSimValue: ToSimValueWithType<::Type> { - type Type: Type; - - #[track_caller] - fn to_sim_value(&self) -> SimValue; - #[track_caller] - fn into_sim_value(self) -> SimValue - where - Self: Sized, - { - self.to_sim_value() - } - #[track_caller] - fn arc_into_sim_value(self: Arc) -> SimValue { - self.to_sim_value() - } - #[track_caller] - fn arc_to_sim_value(self: &Arc) -> SimValue { - self.to_sim_value() - } -} - -pub trait ToSimValueWithType { - #[track_caller] - fn to_sim_value_with_type(&self, ty: T) -> SimValue; - #[track_caller] - fn into_sim_value_with_type(self, ty: T) -> SimValue - where - Self: Sized, - { - self.to_sim_value_with_type(ty) - } - #[track_caller] - fn arc_into_sim_value_with_type(self: Arc, ty: T) -> SimValue { - self.to_sim_value_with_type(ty) - } - #[track_caller] - fn arc_to_sim_value_with_type(self: &Arc, ty: T) -> SimValue { - self.to_sim_value_with_type(ty) - } -} - -macro_rules! forward_to_sim_value_with_type { - ([$($generics:tt)*] $ty:ty) => { - impl<$($generics)*> ToSimValueWithType<::Type> for $ty { - fn to_sim_value_with_type(&self, ty: ::Type) -> SimValue<::Type> { - let retval = Self::to_sim_value(self); - assert_eq!(SimValue::ty(&retval), ty); - retval - } - #[track_caller] - fn into_sim_value_with_type(self, ty: ::Type) -> SimValue<::Type> - where - Self: Sized, - { - let retval = Self::into_sim_value(self); - assert_eq!(SimValue::ty(&retval), ty); - retval - } - #[track_caller] - fn arc_into_sim_value_with_type(self: Arc, ty: ::Type) -> SimValue<::Type> { - let retval = Self::arc_into_sim_value(self); - assert_eq!(SimValue::ty(&retval), ty); - retval - } - #[track_caller] - fn arc_to_sim_value_with_type(self: &Arc, ty: ::Type) -> SimValue<::Type> { - let retval = Self::arc_to_sim_value(self); - assert_eq!(SimValue::ty(&retval), ty); - retval - } - } - }; -} - -impl ToSimValue for SimValue { - type Type = T; - fn to_sim_value(&self) -> SimValue { - self.clone() - } - - fn into_sim_value(self) -> SimValue { - self - } -} - -forward_to_sim_value_with_type!([T: Type] SimValue); - -impl ToSimValueWithType for BitVec { - #[track_caller] - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - self.clone().into_sim_value_with_type(ty) - } - - #[track_caller] - fn into_sim_value_with_type(self, ty: T) -> SimValue { - Arc::new(self).arc_into_sim_value_with_type(ty) - } - - #[track_caller] - fn arc_into_sim_value_with_type(self: Arc, ty: T) -> SimValue { - SimValue::from_bits(ty, UIntValue::new_dyn(self)) - } - - #[track_caller] - fn arc_to_sim_value_with_type(self: &Arc, ty: T) -> SimValue { - SimValue::from_bits(ty, UIntValue::new_dyn(self.clone())) - } -} - -impl ToSimValueWithType for bitvec::boxed::BitBox { - #[track_caller] - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - self.clone().into_sim_value_with_type(ty) - } - - #[track_caller] - fn into_sim_value_with_type(self, ty: T) -> SimValue { - self.into_bitvec().into_sim_value_with_type(ty) - } -} - -impl ToSimValueWithType for BitSlice { - #[track_caller] - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - self.to_bitvec().into_sim_value_with_type(ty) - } -} - -impl ToSimValue for &'_ This { - type Type = This::Type; - - fn to_sim_value(&self) -> SimValue { - This::to_sim_value(self) - } -} - -impl, T: Type> ToSimValueWithType for &'_ This { - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - This::to_sim_value_with_type(self, ty) - } -} - -impl ToSimValue for &'_ mut This { - type Type = This::Type; - - fn to_sim_value(&self) -> SimValue { - This::to_sim_value(self) - } -} - -impl, T: Type> ToSimValueWithType for &'_ mut This { - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - This::to_sim_value_with_type(self, ty) - } -} - -impl ToSimValue for Arc { - type Type = This::Type; - - fn to_sim_value(&self) -> SimValue { - This::arc_to_sim_value(self) - } - fn into_sim_value(self) -> SimValue { - This::arc_into_sim_value(self) - } -} - -impl, T: Type> ToSimValueWithType for Arc { - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - This::arc_to_sim_value_with_type(self, ty) - } - fn into_sim_value_with_type(self, ty: T) -> SimValue { - This::arc_into_sim_value_with_type(self, ty) - } -} - -impl ToSimValue - for crate::intern::Interned -{ - type Type = This::Type; - fn to_sim_value(&self) -> SimValue { - This::to_sim_value(self) - } -} - -impl + Send + Sync + 'static, T: Type> ToSimValueWithType - for crate::intern::Interned -{ - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - This::to_sim_value_with_type(self, ty) - } -} - -impl ToSimValue for Box { - type Type = This::Type; - - fn to_sim_value(&self) -> SimValue { - This::to_sim_value(self) - } - fn into_sim_value(self) -> SimValue { - This::into_sim_value(*self) - } -} - -impl, T: Type> ToSimValueWithType for Box { - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - This::to_sim_value_with_type(self, ty) - } - fn into_sim_value_with_type(self, ty: T) -> SimValue { - This::into_sim_value_with_type(*self, ty) - } -} - -impl SimValue> { - #[track_caller] - pub fn from_array_elements>>( - ty: ArrayType, - elements: I, - ) -> Self { - let element_ty = ty.element(); - let elements = Vec::from_iter( - elements - .into_iter() - .map(|element| element.into_sim_value_with_type(element_ty)), - ); - assert_eq!(elements.len(), ty.len()); - SimValue::from_value(ty, elements.try_into().ok().expect("already checked len")) - } -} - -impl, T: Type> ToSimValueWithType> for [Element] { - #[track_caller] - fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } -} - -impl> ToSimValue for [Element] { - type Type = Array; - - #[track_caller] - fn to_sim_value(&self) -> SimValue { - SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) - } -} - -impl> ToSimValueWithType for [Element] { - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl, T: Type, const N: usize> ToSimValueWithType> - for [Element; N] -where - ConstUsize: KnownSize, -{ - #[track_caller] - fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } -} - -impl, const N: usize> ToSimValue for [Element; N] -where - ConstUsize: KnownSize, -{ - type Type = Array; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_array_elements(StaticType::TYPE, self) - } - - fn into_sim_value(self) -> SimValue { - SimValue::from_array_elements(StaticType::TYPE, self) - } -} - -impl, T: Type, const N: usize> ToSimValueWithType> - for [Element; N] -{ - #[track_caller] - fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } -} - -impl, const N: usize> ToSimValueWithType - for [Element; N] -{ - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl, T: Type> ToSimValueWithType> for Vec { - #[track_caller] - fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } -} - -impl> ToSimValue for Vec { - type Type = Array; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) - } - - fn into_sim_value(self) -> SimValue { - SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) - } -} - -impl> ToSimValueWithType - for Vec -{ - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl, T: Type> ToSimValueWithType> for Box<[Element]> { - #[track_caller] - fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) - } -} - -impl> ToSimValue for Box<[Element]> { - type Type = Array; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) - } - - fn into_sim_value(self) -> SimValue { - SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) - } -} - -impl> ToSimValueWithType - for Box<[Element]> -{ - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } - #[track_caller] - fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl ToSimValue for Expr { - type Type = T; - #[track_caller] - fn to_sim_value(&self) -> SimValue { - SimValue::from_bitslice( - Expr::ty(*self), - &crate::expr::ToLiteralBits::to_literal_bits(self) - .expect("must be a literal expression"), - ) - } -} - -forward_to_sim_value_with_type!([T: Type] Expr); - -macro_rules! impl_to_sim_value_for_bool_like { - ($ty:ident) => { - impl ToSimValueWithType<$ty> for bool { - fn to_sim_value_with_type(&self, ty: $ty) -> SimValue<$ty> { - SimValue::from_value(ty, *self) - } - } - }; -} - -impl ToSimValue for bool { - type Type = Bool; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_value(Bool, *self) - } -} - -impl_to_sim_value_for_bool_like!(Bool); -impl_to_sim_value_for_bool_like!(AsyncReset); -impl_to_sim_value_for_bool_like!(SyncReset); -impl_to_sim_value_for_bool_like!(Reset); -impl_to_sim_value_for_bool_like!(Clock); - -impl ToSimValueWithType for bool { - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - match ty { - CanonicalType::UInt(_) - | CanonicalType::SInt(_) - | CanonicalType::Array(_) - | CanonicalType::Enum(_) - | CanonicalType::Bundle(_) - | CanonicalType::PhantomConst(_) => { - panic!("can't create SimValue from bool: expected value of type: {ty:?}"); - } - CanonicalType::Bool(_) - | CanonicalType::AsyncReset(_) - | CanonicalType::SyncReset(_) - | CanonicalType::Reset(_) - | CanonicalType::Clock(_) => { - SimValue::from_bits(ty, UIntValue::new(Arc::new(BitVec::repeat(*self, 1)))) - } - } - } -} - -macro_rules! impl_to_sim_value_for_primitive_int { - ($prim:ident) => { - impl ToSimValue for $prim { - type Type = <$prim as ToExpr>::Type; - - #[track_caller] - fn to_sim_value( - &self, - ) -> SimValue { - SimValue::from_value(StaticType::TYPE, (*self).into()) - } - } - - forward_to_sim_value_with_type!([] $prim); - - impl ToSimValueWithType<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { - #[track_caller] - fn to_sim_value_with_type( - &self, - ty: <<$prim as ToExpr>::Type as IntType>::Dyn, - ) -> SimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> { - SimValue::from_value( - ty, - <<$prim as ToExpr>::Type as Type>::SimValue::from(*self).as_dyn_int(), - ) - } - } - - impl ToSimValueWithType for $prim { - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - let ty: <<$prim as ToExpr>::Type as IntType>::Dyn = Type::from_canonical(ty); - SimValue::into_canonical(self.to_sim_value_with_type(ty)) - } - } - }; -} - -impl_to_sim_value_for_primitive_int!(u8); -impl_to_sim_value_for_primitive_int!(u16); -impl_to_sim_value_for_primitive_int!(u32); -impl_to_sim_value_for_primitive_int!(u64); -impl_to_sim_value_for_primitive_int!(u128); -impl_to_sim_value_for_primitive_int!(usize); -impl_to_sim_value_for_primitive_int!(i8); -impl_to_sim_value_for_primitive_int!(i16); -impl_to_sim_value_for_primitive_int!(i32); -impl_to_sim_value_for_primitive_int!(i64); -impl_to_sim_value_for_primitive_int!(i128); -impl_to_sim_value_for_primitive_int!(isize); - -macro_rules! impl_to_sim_value_for_int_value { - ($IntValue:ident, $Int:ident, $IntType:ident) => { - impl ToSimValue for $IntValue { - type Type = $IntType; - - fn to_sim_value(&self) -> SimValue { - SimValue::from_value(self.ty(), self.clone()) - } - - fn into_sim_value(self) -> SimValue { - SimValue::from_value(self.ty(), self) - } - } - - impl ToSimValueWithType<$IntType> for $IntValue { - fn to_sim_value_with_type(&self, ty: $IntType) -> SimValue<$IntType> { - SimValue::from_value(ty, self.clone()) - } - - fn into_sim_value_with_type(self, ty: $IntType) -> SimValue<$IntType> { - SimValue::from_value(ty, self) - } - } - - impl ToSimValueWithType<$Int> for $IntValue { - fn to_sim_value_with_type(&self, ty: $Int) -> SimValue<$Int> { - self.bits().to_sim_value_with_type(ty) - } - - fn into_sim_value_with_type(self, ty: $Int) -> SimValue<$Int> { - self.into_bits().into_sim_value_with_type(ty) - } - } - - impl ToSimValueWithType for $IntValue { - #[track_caller] - fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical( - self.to_sim_value_with_type($IntType::::from_canonical(ty)), - ) - } - - #[track_caller] - fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical( - self.into_sim_value_with_type($IntType::::from_canonical(ty)), - ) - } - } - }; -} - -impl_to_sim_value_for_int_value!(UIntValue, UInt, UIntType); -impl_to_sim_value_for_int_value!(SIntValue, SInt, SIntType); diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs index 8f41c5c..2786782 100644 --- a/crates/fayalite/src/ty.rs +++ b/crates/fayalite/src/ty.rs @@ -7,19 +7,14 @@ use crate::{ clock::Clock, enum_::Enum, expr::Expr, - int::{Bool, SInt, UInt, UIntValue}, + int::{Bool, SInt, UInt}, intern::{Intern, Interned}, phantom_const::PhantomConst, reset::{AsyncReset, Reset, SyncReset}, - sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, util::ConstUsize, }; -use bitvec::slice::BitSlice; -use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize, Serializer}; -use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index, sync::Arc}; - -pub(crate) mod serde_impls; +use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index}; #[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)] #[non_exhaustive] @@ -63,24 +58,6 @@ impl fmt::Debug for CanonicalType { } } -impl Serialize for CanonicalType { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serde_impls::SerdeCanonicalType::from(*self).serialize(serializer) - } -} - -impl<'de> Deserialize<'de> for CanonicalType { - fn deserialize(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - Ok(serde_impls::SerdeCanonicalType::deserialize(deserializer)?.into()) - } -} - impl CanonicalType { pub fn type_properties(self) -> TypeProperties { match self { @@ -179,9 +156,6 @@ impl CanonicalType { } } } - pub(crate) fn as_serde_unexpected_str(self) -> &'static str { - serde_impls::SerdeCanonicalType::from(self).as_serde_unexpected_str() - } } pub trait MatchVariantAndInactiveScope: Sized { @@ -248,34 +222,6 @@ macro_rules! impl_base_type { }; } -macro_rules! impl_base_type_serde { - ($name:ident, $expected:literal) => { - impl Serialize for $name { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.canonical().serialize(serializer) - } - } - - impl<'de> Deserialize<'de> for $name { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - match CanonicalType::deserialize(deserializer)? { - CanonicalType::$name(retval) => Ok(retval), - ty => Err(serde::de::Error::invalid_value( - serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), - &$expected, - )), - } - } - } - }; -} - impl_base_type!(UInt); impl_base_type!(SInt); impl_base_type!(Bool); @@ -288,14 +234,6 @@ impl_base_type!(Reset); impl_base_type!(Clock); impl_base_type!(PhantomConst); -impl_base_type_serde!(Bool, "a Bool"); -impl_base_type_serde!(Enum, "an Enum"); -impl_base_type_serde!(Bundle, "a Bundle"); -impl_base_type_serde!(AsyncReset, "an AsyncReset"); -impl_base_type_serde!(SyncReset, "a SyncReset"); -impl_base_type_serde!(Reset, "a Reset"); -impl_base_type_serde!(Clock, "a Clock"); - impl sealed::BaseTypeSealed for CanonicalType {} impl BaseType for CanonicalType {} @@ -330,7 +268,6 @@ pub trait Type: { type BaseType: BaseType; type MaskType: Type; - type SimValue: fmt::Debug + Clone + 'static + ToSimValueWithType; type MatchVariant: 'static + Send + Sync; type MatchActiveScope; type MatchVariantAndInactiveScope: MatchVariantAndInactiveScope< @@ -348,22 +285,9 @@ pub trait Type: fn canonical(&self) -> CanonicalType; fn from_canonical(canonical_type: CanonicalType) -> Self; fn source_location() -> SourceLocation; - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue; - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice); - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice); } -pub trait BaseType: - Type< - BaseType = Self, - MaskType: Serialize + DeserializeOwned, - SimValue: Serialize + DeserializeOwned, - > + sealed::BaseTypeSealed - + Into - + Serialize - + DeserializeOwned -{ -} +pub trait BaseType: Type + sealed::BaseTypeSealed + Into {} macro_rules! impl_match_variant_as_self { () => { @@ -390,7 +314,6 @@ pub trait TypeWithDeref: Type { impl Type for CanonicalType { type BaseType = CanonicalType; type MaskType = CanonicalType; - type SimValue = OpaqueSimValue; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { match self { @@ -416,60 +339,9 @@ impl Type for CanonicalType { fn source_location() -> SourceLocation { SourceLocation::builtin() } - fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { - assert_eq!(bits.len(), self.bit_width()); - OpaqueSimValue::from_bitslice(bits) - } - fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { - assert_eq!(bits.len(), self.bit_width()); - assert_eq!(value.bit_width(), self.bit_width()); - value.bits_mut().bits_mut().copy_from_bitslice(bits); - } - fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { - assert_eq!(bits.len(), self.bit_width()); - assert_eq!(value.bit_width(), self.bit_width()); - bits.copy_from_bitslice(value.bits().bits()); - } } -#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)] -pub struct OpaqueSimValue { - bits: UIntValue, -} - -impl OpaqueSimValue { - pub fn bit_width(&self) -> usize { - self.bits.width() - } - pub fn bits(&self) -> &UIntValue { - &self.bits - } - pub fn bits_mut(&mut self) -> &mut UIntValue { - &mut self.bits - } - pub fn into_bits(self) -> UIntValue { - self.bits - } - pub fn from_bits(bits: UIntValue) -> Self { - Self { bits } - } - pub fn from_bitslice(v: &BitSlice) -> Self { - Self { - bits: UIntValue::new(Arc::new(v.to_bitvec())), - } - } -} - -impl> ToSimValueWithType for OpaqueSimValue { - fn to_sim_value_with_type(&self, ty: T) -> SimValue { - SimValue::from_value(ty, self.clone()) - } - fn into_sim_value_with_type(self, ty: T) -> SimValue { - SimValue::from_value(ty, self) - } -} - -pub trait StaticType: Type + Default { +pub trait StaticType: Type { const TYPE: Self; const MASK_TYPE: Self::MaskType; const TYPE_PROPERTIES: TypeProperties; diff --git a/crates/fayalite/src/ty/serde_impls.rs b/crates/fayalite/src/ty/serde_impls.rs deleted file mode 100644 index 2ea4362..0000000 --- a/crates/fayalite/src/ty/serde_impls.rs +++ /dev/null @@ -1,130 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// See Notices.txt for copyright information - -use crate::{ - array::Array, - bundle::{Bundle, BundleType}, - clock::Clock, - enum_::{Enum, EnumType}, - int::{Bool, SInt, UInt}, - intern::Interned, - phantom_const::{PhantomConstCanonicalValue, PhantomConstValue}, - prelude::PhantomConst, - reset::{AsyncReset, Reset, SyncReset}, - ty::{BaseType, CanonicalType}, -}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -pub(crate) struct SerdePhantomConst(pub T); - -impl Serialize for SerdePhantomConst> { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.0.serialize(serializer) - } -} - -impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for SerdePhantomConst> { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - T::deserialize_value(deserializer).map(Self) - } -} - -#[derive(Serialize, Deserialize)] -#[serde(rename = "CanonicalType")] -pub(crate) enum SerdeCanonicalType< - ArrayElement = CanonicalType, - ThePhantomConst = SerdePhantomConst>, -> { - UInt { - width: usize, - }, - SInt { - width: usize, - }, - Bool, - Array { - element: ArrayElement, - len: usize, - }, - Enum { - variants: Interned<[crate::enum_::EnumVariant]>, - }, - Bundle { - fields: Interned<[crate::bundle::BundleField]>, - }, - AsyncReset, - SyncReset, - Reset, - Clock, - PhantomConst(ThePhantomConst), -} - -impl SerdeCanonicalType { - pub(crate) fn as_serde_unexpected_str(&self) -> &'static str { - match self { - Self::UInt { .. } => "a UInt", - Self::SInt { .. } => "a SInt", - Self::Bool => "a Bool", - Self::Array { .. } => "an Array", - Self::Enum { .. } => "an Enum", - Self::Bundle { .. } => "a Bundle", - Self::AsyncReset => "an AsyncReset", - Self::SyncReset => "a SyncReset", - Self::Reset => "a Reset", - Self::Clock => "a Clock", - Self::PhantomConst(_) => "a PhantomConst", - } - } -} - -impl From for SerdeCanonicalType { - fn from(ty: T) -> Self { - let ty: CanonicalType = ty.into(); - match ty { - CanonicalType::UInt(ty) => Self::UInt { width: ty.width() }, - CanonicalType::SInt(ty) => Self::SInt { width: ty.width() }, - CanonicalType::Bool(Bool {}) => Self::Bool, - CanonicalType::Array(ty) => Self::Array { - element: ty.element(), - len: ty.len(), - }, - CanonicalType::Enum(ty) => Self::Enum { - variants: ty.variants(), - }, - CanonicalType::Bundle(ty) => Self::Bundle { - fields: ty.fields(), - }, - CanonicalType::AsyncReset(AsyncReset {}) => Self::AsyncReset, - CanonicalType::SyncReset(SyncReset {}) => Self::SyncReset, - CanonicalType::Reset(Reset {}) => Self::Reset, - CanonicalType::Clock(Clock {}) => Self::Clock, - CanonicalType::PhantomConst(ty) => Self::PhantomConst(SerdePhantomConst(ty.get())), - } - } -} - -impl From for CanonicalType { - fn from(ty: SerdeCanonicalType) -> Self { - match ty { - SerdeCanonicalType::UInt { width } => Self::UInt(UInt::new(width)), - SerdeCanonicalType::SInt { width } => Self::SInt(SInt::new(width)), - SerdeCanonicalType::Bool => Self::Bool(Bool), - SerdeCanonicalType::Array { element, len } => Self::Array(Array::new(element, len)), - SerdeCanonicalType::Enum { variants } => Self::Enum(Enum::new(variants)), - SerdeCanonicalType::Bundle { fields } => Self::Bundle(Bundle::new(fields)), - SerdeCanonicalType::AsyncReset => Self::AsyncReset(AsyncReset), - SerdeCanonicalType::SyncReset => Self::SyncReset(SyncReset), - SerdeCanonicalType::Reset => Self::Reset(Reset), - SerdeCanonicalType::Clock => Self::Clock(Clock), - SerdeCanonicalType::PhantomConst(value) => { - Self::PhantomConst(PhantomConst::new(value.0)) - } - } - } -} diff --git a/crates/fayalite/src/util.rs b/crates/fayalite/src/util.rs index 804ff19..66fc921 100644 --- a/crates/fayalite/src/util.rs +++ b/crates/fayalite/src/util.rs @@ -1,7 +1,6 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -pub(crate) mod alternating_cell; mod const_bool; mod const_cmp; mod const_usize; diff --git a/crates/fayalite/src/util/alternating_cell.rs b/crates/fayalite/src/util/alternating_cell.rs deleted file mode 100644 index 17e06a6..0000000 --- a/crates/fayalite/src/util/alternating_cell.rs +++ /dev/null @@ -1,122 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// See Notices.txt for copyright information - -use crate::util::DebugAsDisplay; -use std::{ - cell::{Cell, UnsafeCell}, - fmt, -}; - -pub(crate) trait AlternatingCellMethods { - fn unique_to_shared(&mut self); - fn shared_to_unique(&mut self); -} - -#[derive(Copy, Clone, Debug)] -enum State { - Unique, - Shared, - Locked, -} - -pub(crate) struct AlternatingCell { - state: Cell, - value: UnsafeCell, -} - -impl fmt::Debug for AlternatingCell { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("AlternatingCell") - .field( - self.try_share() - .as_ref() - .map(|v| -> &dyn fmt::Debug { v }) - .unwrap_or(&DebugAsDisplay("<...>")), - ) - .finish() - } -} - -impl AlternatingCell { - pub(crate) const fn new_shared(value: T) -> Self - where - T: Sized, - { - Self { - state: Cell::new(State::Shared), - value: UnsafeCell::new(value), - } - } - pub(crate) const fn new_unique(value: T) -> Self - where - T: Sized, - { - Self { - state: Cell::new(State::Unique), - value: UnsafeCell::new(value), - } - } - pub(crate) fn is_unique(&self) -> bool { - matches!(self.state.get(), State::Unique) - } - pub(crate) fn is_shared(&self) -> bool { - matches!(self.state.get(), State::Shared) - } - pub(crate) fn into_inner(self) -> T - where - T: Sized, - { - self.value.into_inner() - } - pub(crate) fn try_share(&self) -> Option<&T> - where - T: AlternatingCellMethods, - { - match self.state.get() { - State::Shared => {} - State::Unique => { - struct Locked<'a>(&'a Cell); - impl Drop for Locked<'_> { - fn drop(&mut self) { - self.0.set(State::Shared); - } - } - self.state.set(State::Locked); - let lock = Locked(&self.state); - // Safety: state is Locked, so nothing else will - // access value while calling unique_to_shared. - unsafe { &mut *self.value.get() }.unique_to_shared(); - drop(lock); - } - State::Locked => return None, - } - - // Safety: state is Shared so nothing will create any mutable - // references until the returned reference's lifetime expires. - Some(unsafe { &*self.value.get() }) - } - #[track_caller] - pub(crate) fn share(&self) -> &T - where - T: AlternatingCellMethods, - { - let Some(retval) = self.try_share() else { - panic!("`share` called recursively"); - }; - retval - } - pub(crate) fn unique(&mut self) -> &mut T - where - T: AlternatingCellMethods, - { - match self.state.get() { - State::Shared => { - self.state.set(State::Unique); - self.value.get_mut().shared_to_unique(); - } - State::Unique => {} - State::Locked => unreachable!(), - } - self.value.get_mut() - } -} diff --git a/crates/fayalite/src/util/const_bool.rs b/crates/fayalite/src/util/const_bool.rs index 7def3b5..7033d6a 100644 --- a/crates/fayalite/src/util/const_bool.rs +++ b/crates/fayalite/src/util/const_bool.rs @@ -1,9 +1,5 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use serde::{ - de::{DeserializeOwned, Error, Unexpected}, - Deserialize, Deserializer, Serialize, Serializer, -}; use std::{fmt::Debug, hash::Hash, mem::ManuallyDrop, ptr}; mod sealed { @@ -13,17 +9,7 @@ mod sealed { /// # Safety /// the only implementation is `ConstBool` pub unsafe trait GenericConstBool: - sealed::Sealed - + Copy - + Ord - + Hash - + Default - + Debug - + 'static - + Send - + Sync - + Serialize - + DeserializeOwned + sealed::Sealed + Copy + Ord + Hash + Default + Debug + 'static + Send + Sync { const VALUE: bool; } @@ -44,32 +30,6 @@ unsafe impl GenericConstBool for ConstBool { const VALUE: bool = VALUE; } -impl Serialize for ConstBool { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - VALUE.serialize(serializer) - } -} - -impl<'de, const VALUE: bool> Deserialize<'de> for ConstBool { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let value = bool::deserialize(deserializer)?; - if value == VALUE { - Ok(ConstBool) - } else { - Err(D::Error::invalid_value( - Unexpected::Bool(value), - &if VALUE { "true" } else { "false" }, - )) - } - } -} - pub trait ConstBoolDispatchTag { type Type; } diff --git a/crates/fayalite/src/util/const_usize.rs b/crates/fayalite/src/util/const_usize.rs index e098a12..a605336 100644 --- a/crates/fayalite/src/util/const_usize.rs +++ b/crates/fayalite/src/util/const_usize.rs @@ -1,9 +1,5 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use serde::{ - de::{DeserializeOwned, Error, Unexpected}, - Deserialize, Deserializer, Serialize, Serializer, -}; use std::{fmt::Debug, hash::Hash}; mod sealed { @@ -12,17 +8,7 @@ mod sealed { /// the only implementation is `ConstUsize` pub trait GenericConstUsize: - sealed::Sealed - + Copy - + Ord - + Hash - + Default - + Debug - + 'static - + Send - + Sync - + Serialize - + DeserializeOwned + sealed::Sealed + Copy + Ord + Hash + Default + Debug + 'static + Send + Sync { const VALUE: usize; } @@ -41,29 +27,3 @@ impl sealed::Sealed for ConstUsize {} impl GenericConstUsize for ConstUsize { const VALUE: usize = VALUE; } - -impl Serialize for ConstUsize { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - VALUE.serialize(serializer) - } -} - -impl<'de, const VALUE: usize> Deserialize<'de> for ConstUsize { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let value = usize::deserialize(deserializer)?; - if value == VALUE { - Ok(ConstUsize) - } else { - Err(D::Error::invalid_value( - Unexpected::Unsigned(value as u64), - &&*VALUE.to_string(), - )) - } - } -} diff --git a/crates/fayalite/src/util/prefix_sum.rs b/crates/fayalite/src/util/prefix_sum.rs index 98e6d95..758d89c 100644 --- a/crates/fayalite/src/util/prefix_sum.rs +++ b/crates/fayalite/src/util/prefix_sum.rs @@ -210,10 +210,10 @@ impl PrefixSumOp { #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub enum PrefixSumAlgorithm { /// Uses the algorithm from: - /// + /// https://en.wikipedia.org/wiki/Prefix_sum#Algorithm_1:_Shorter_span,_more_parallel LowLatency, /// Uses the algorithm from: - /// + /// https://en.wikipedia.org/wiki/Prefix_sum#Algorithm_2:_Work-efficient WorkEfficient, } diff --git a/crates/fayalite/tests/hdl_types.rs b/crates/fayalite/tests/hdl_types.rs index 8802fd4..b191016 100644 --- a/crates/fayalite/tests/hdl_types.rs +++ b/crates/fayalite/tests/hdl_types.rs @@ -4,17 +4,11 @@ use fayalite::{ bundle::BundleType, enum_::EnumType, int::{BoolOrIntType, IntType}, - phantom_const::PhantomConst, prelude::*, ty::StaticType, }; use std::marker::PhantomData; -#[hdl(outline_generated)] -pub struct MyConstSize { - pub size: PhantomConst>, -} - #[hdl(outline_generated)] pub struct S { pub a: T, diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs index 655a497..6d20715 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -2,11 +2,11 @@ // See Notices.txt for copyright information use fayalite::{ - memory::{ReadStruct, ReadWriteStruct, WriteStruct}, - module::{instance_with_loc, reg_builder_with_loc}, + int::UIntValue, prelude::*, reset::ResetType, - sim::vcd::VcdWriterDecls, + sim::{time::SimDuration, vcd::VcdWriterDecls, Simulation, ToSimValue}, + ty::StaticType, util::RcWriter, }; use std::num::NonZeroUsize; @@ -316,13 +316,8 @@ pub fn enums() { let which_out: UInt<2> = m.output(); #[hdl] let data_out: UInt<4> = m.output(); - let b_out_ty = HdlOption[(UInt[1], Bool)]; #[hdl] - let b_out: HdlOption<(UInt, Bool)> = m.output(HdlOption[(UInt[1], Bool)]); - #[hdl] - let b2_out: HdlOption<(UInt<1>, Bool)> = m.output(); - - connect_any(b2_out, b_out); + let b_out: HdlOption<(UInt<1>, Bool)> = m.output(); #[hdl] struct MyStruct { @@ -362,7 +357,7 @@ pub fn enums() { } } - connect(b_out, b_out_ty.HdlNone()); + connect(b_out, HdlNone()); #[hdl] match the_reg { @@ -373,7 +368,7 @@ pub fn enums() { MyEnum::B(v) => { connect(which_out, 1_hdl_u2); connect_any(data_out, v.0 | (v.1.cast_to_static::>() << 1)); - connect_any(b_out, HdlSome(v)); + connect(b_out, HdlSome(v)); } MyEnum::C(v) => { connect(which_out, 2_hdl_u2); @@ -389,136 +384,132 @@ fn test_enums() { let mut sim = Simulation::new(enums()); let mut writer = RcWriter::default(); sim.add_trace_writer(VcdWriterDecls::new(writer.clone())); - sim.write(sim.io().cd.clk, false); - sim.write(sim.io().cd.rst, true); - sim.write(sim.io().en, false); - sim.write(sim.io().which_in, 0_hdl_u2); - sim.write(sim.io().data_in, 0_hdl_u4); + sim.write_clock(sim.io().cd.clk, false); + sim.write_reset(sim.io().cd.rst, true); + sim.write_bool(sim.io().en, false); + sim.write_bool_or_int(sim.io().which_in, 0_hdl_u2); + sim.write_bool_or_int(sim.io().data_in, 0_hdl_u4); sim.advance_time(SimDuration::from_micros(1)); - sim.write(sim.io().cd.clk, true); + sim.write_clock(sim.io().cd.clk, true); sim.advance_time(SimDuration::from_nanos(100)); - sim.write(sim.io().cd.rst, false); + sim.write_reset(sim.io().cd.rst, false); sim.advance_time(SimDuration::from_nanos(900)); - #[hdl(cmp_eq)] - struct IO { - en: Bool, - which_in: UInt<2>, - data_in: UInt<4>, - which_out: UInt<2>, - data_out: UInt<4>, - b_out: HdlOption<(UIntType, Bool)>, - b2_out: HdlOption<(UInt<1>, Bool)>, + type BOutTy = HdlOption<(UInt<1>, Bool)>; + #[derive(Debug)] + struct IO { + en: bool, + which_in: u8, + data_in: u8, + which_out: u8, + data_out: u8, + b_out: Expr, + } + impl PartialEq for IO { + fn eq(&self, other: &Self) -> bool { + let Self { + en, + which_in, + data_in, + which_out, + data_out, + b_out, + } = *self; + en == other.en + && which_in == other.which_in + && data_in == other.data_in + && which_out == other.which_out + && data_out == other.data_out + && b_out.to_sim_value(BOutTy::TYPE) == other.b_out.to_sim_value(BOutTy::TYPE) + } } - let io_ty = IO[1]; let io_cycles = [ - #[hdl(sim)] - IO::<_> { + IO { en: false, - which_in: 0_hdl_u2, - data_in: 0_hdl_u4, - which_out: 0_hdl_u2, - data_out: 0_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlNone(), - b2_out: #[hdl(sim)] - HdlNone(), + which_in: 0, + data_in: 0, + which_out: 0, + data_out: 0, + b_out: HdlNone(), }, - #[hdl(sim)] - IO::<_> { + IO { en: true, - which_in: 1_hdl_u2, - data_in: 0_hdl_u4, - which_out: 0_hdl_u2, - data_out: 0_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlNone(), - b2_out: #[hdl(sim)] - HdlNone(), + which_in: 1, + data_in: 0, + which_out: 0, + data_out: 0, + b_out: HdlNone(), }, - #[hdl(sim)] - IO::<_> { + IO { en: false, - which_in: 0_hdl_u2, - data_in: 0_hdl_u4, - which_out: 1_hdl_u2, - data_out: 0_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlSome((0u8.cast_to(UInt[1]), false)), - b2_out: #[hdl(sim)] - HdlSome((0_hdl_u1, false)), + which_in: 0, + data_in: 0, + which_out: 1, + data_out: 0, + b_out: HdlSome((0_hdl_u1, false)), }, - #[hdl(sim)] - IO::<_> { + IO { en: true, - which_in: 1_hdl_u2, - data_in: 0xF_hdl_u4, - which_out: 1_hdl_u2, - data_out: 0_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlSome((0u8.cast_to(UInt[1]), false)), - b2_out: #[hdl(sim)] - HdlSome((0_hdl_u1, false)), + which_in: 1, + data_in: 0xF, + which_out: 1, + data_out: 0, + b_out: HdlSome((0_hdl_u1, false)), }, - #[hdl(sim)] - IO::<_> { + IO { en: true, - which_in: 1_hdl_u2, - data_in: 0xF_hdl_u4, - which_out: 1_hdl_u2, - data_out: 0x3_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlSome((1u8.cast_to(UInt[1]), true)), - b2_out: #[hdl(sim)] - HdlSome((1_hdl_u1, true)), + which_in: 1, + data_in: 0xF, + which_out: 1, + data_out: 0x3, + b_out: HdlSome((1_hdl_u1, true)), }, - #[hdl(sim)] - IO::<_> { + IO { en: true, - which_in: 2_hdl_u2, - data_in: 0xF_hdl_u4, - which_out: 1_hdl_u2, - data_out: 0x3_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlSome((1u8.cast_to(UInt[1]), true)), - b2_out: #[hdl(sim)] - HdlSome((1_hdl_u1, true)), + which_in: 2, + data_in: 0xF, + which_out: 1, + data_out: 0x3, + b_out: HdlSome((1_hdl_u1, true)), }, - #[hdl(sim)] - IO::<_> { + IO { en: true, - which_in: 2_hdl_u2, - data_in: 0xF_hdl_u4, - which_out: 2_hdl_u2, - data_out: 0xF_hdl_u4, - b_out: #[hdl(sim)] - (io_ty.b_out).HdlNone(), - b2_out: #[hdl(sim)] - HdlNone(), + which_in: 2, + data_in: 0xF, + which_out: 2, + data_out: 0xF, + b_out: HdlNone(), }, ]; - for (cycle, expected) in io_cycles.into_iter().enumerate() { - #[hdl(sim)] - let IO::<_> { + for ( + cycle, + expected @ IO { en, which_in, data_in, which_out: _, data_out: _, b_out: _, - b2_out: _, - } = expected; - sim.write(sim.io().en, &en); - sim.write(sim.io().which_in, &which_in); - sim.write(sim.io().data_in, &data_in); - let io = #[hdl(sim)] - IO::<_> { + }, + ) in io_cycles.into_iter().enumerate() + { + sim.write_bool(sim.io().en, en); + sim.write_bool_or_int(sim.io().which_in, which_in.cast_to_static()); + sim.write_bool_or_int(sim.io().data_in, data_in.cast_to_static()); + let io = IO { en, which_in, data_in, - which_out: sim.read(sim.io().which_out), - data_out: sim.read(sim.io().data_out), - b_out: sim.read(sim.io().b_out), - b2_out: sim.read(sim.io().b2_out), + which_out: sim + .read_bool_or_int(sim.io().which_out) + .to_bigint() + .try_into() + .expect("known to be in range"), + data_out: sim + .read_bool_or_int(sim.io().data_out) + .to_bigint() + .try_into() + .expect("known to be in range"), + b_out: sim.read(sim.io().b_out).to_expr(), }; assert_eq!( expected, @@ -526,12 +517,6 @@ fn test_enums() { "vcd:\n{}\ncycle: {cycle}", String::from_utf8(writer.take()).unwrap(), ); - // make sure matching on SimValue works - #[hdl(sim)] - match io.b_out { - HdlNone => println!("io.b_out is HdlNone"), - HdlSome(v) => println!("io.b_out is HdlSome(({:?}, {:?}))", *v.0, *v.1), - } sim.write_clock(sim.io().cd.clk, false); sim.advance_time(SimDuration::from_micros(1)); sim.write_clock(sim.io().cd.clk, true); @@ -553,9 +538,9 @@ fn test_enums() { #[hdl_module(outline_generated)] pub fn memories() { #[hdl] - let r: ReadStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); + let r: fayalite::memory::ReadStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); #[hdl] - let w: WriteStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); + let w: fayalite::memory::WriteStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); #[hdl] let mut mem = memory_with_init([(0x01u8, 0x23i8); 16]); mem.read_latency(0); @@ -574,131 +559,120 @@ fn test_memories() { sim.add_trace_writer(VcdWriterDecls::new(writer.clone())); sim.write_clock(sim.io().r.clk, false); sim.write_clock(sim.io().w.clk, false); - #[hdl(cmp_eq)] + #[derive(Debug, PartialEq, Eq)] struct IO { - r_addr: UInt<4>, - r_en: Bool, - r_data: (UInt<8>, SInt<8>), - w_addr: UInt<4>, - w_en: Bool, - w_data: (UInt<8>, SInt<8>), - w_mask: (Bool, Bool), + r_addr: u8, + r_en: bool, + r_data: (u8, i8), + w_addr: u8, + w_en: bool, + w_data: (u8, i8), + w_mask: (bool, bool), } let io_cycles = [ - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: false, - r_data: (0u8, 0i8), - w_addr: 0_hdl_u4, + r_data: (0, 0), + w_addr: 0, w_en: false, - w_data: (0u8, 0i8), + w_data: (0, 0), w_mask: (false, false), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x1u8, 0x23i8), - w_addr: 0_hdl_u4, + r_data: (0x1, 0x23), + w_addr: 0, w_en: true, - w_data: (0x10u8, 0x20i8), + w_data: (0x10, 0x20), w_mask: (true, true), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x10u8, 0x20i8), - w_addr: 0_hdl_u4, + r_data: (0x10, 0x20), + w_addr: 0, w_en: true, - w_data: (0x30u8, 0x40i8), + w_data: (0x30, 0x40), w_mask: (false, true), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x10u8, 0x40i8), - w_addr: 0_hdl_u4, + r_data: (0x10, 0x40), + w_addr: 0, w_en: true, - w_data: (0x50u8, 0x60i8), + w_data: (0x50, 0x60), w_mask: (true, false), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x50u8, 0x40i8), - w_addr: 0_hdl_u4, + r_data: (0x50, 0x40), + w_addr: 0, w_en: true, - w_data: (0x70u8, -0x80i8), + w_data: (0x70, -0x80), w_mask: (false, false), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x50u8, 0x40i8), - w_addr: 0_hdl_u4, + r_data: (0x50, 0x40), + w_addr: 0, w_en: false, - w_data: (0x90u8, 0xA0u8 as i8), + w_data: (0x90, 0xA0u8 as i8), w_mask: (false, false), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x50u8, 0x40i8), - w_addr: 1_hdl_u4, + r_data: (0x50, 0x40), + w_addr: 1, w_en: true, - w_data: (0x90u8, 0xA0u8 as i8), + w_data: (0x90, 0xA0u8 as i8), w_mask: (true, true), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x50u8, 0x40i8), - w_addr: 2_hdl_u4, + r_data: (0x50, 0x40), + w_addr: 2, w_en: true, - w_data: (0xB0u8, 0xC0u8 as i8), + w_data: (0xB0, 0xC0u8 as i8), w_mask: (true, true), }, - #[hdl(sim)] IO { - r_addr: 0_hdl_u4, + r_addr: 0, r_en: true, - r_data: (0x50u8, 0x40i8), - w_addr: 2_hdl_u4, + r_data: (0x50, 0x40), + w_addr: 2, w_en: false, - w_data: (0xD0u8, 0xE0u8 as i8), + w_data: (0xD0, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl(sim)] IO { - r_addr: 1_hdl_u4, + r_addr: 1, r_en: true, - r_data: (0x90u8, 0xA0u8 as i8), - w_addr: 2_hdl_u4, + r_data: (0x90, 0xA0u8 as i8), + w_addr: 2, w_en: false, - w_data: (0xD0u8, 0xE0u8 as i8), + w_data: (0xD0, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl(sim)] IO { - r_addr: 2_hdl_u4, + r_addr: 2, r_en: true, - r_data: (0xB0u8, 0xC0u8 as i8), - w_addr: 2_hdl_u4, + r_data: (0xB0, 0xC0u8 as i8), + w_addr: 2, w_en: false, - w_data: (0xD0u8, 0xE0u8 as i8), + w_data: (0xD0, 0xE0u8 as i8), w_mask: (true, true), }, ]; - for (cycle, expected) in io_cycles.into_iter().enumerate() { - #[hdl(sim)] - let IO { + for ( + cycle, + expected @ IO { r_addr, r_en, r_data: _, @@ -706,18 +680,30 @@ fn test_memories() { w_en, w_data, w_mask, - } = expected; - sim.write(sim.io().r.addr, &r_addr); - sim.write(sim.io().r.en, &r_en); - sim.write(sim.io().w.addr, &w_addr); - sim.write(sim.io().w.en, &w_en); - sim.write(sim.io().w.data, &w_data); - sim.write(sim.io().w.mask, &w_mask); - let io = #[hdl(sim)] - IO { + }, + ) in io_cycles.into_iter().enumerate() + { + sim.write_bool_or_int(sim.io().r.addr, r_addr.cast_to_static()); + sim.write_bool(sim.io().r.en, r_en); + sim.write_bool_or_int(sim.io().w.addr, w_addr.cast_to_static()); + sim.write_bool(sim.io().w.en, w_en); + sim.write_bool_or_int(sim.io().w.data.0, w_data.0); + sim.write_bool_or_int(sim.io().w.data.1, w_data.1); + sim.write_bool(sim.io().w.mask.0, w_mask.0); + sim.write_bool(sim.io().w.mask.1, w_mask.1); + let io = IO { r_addr, r_en, - r_data: sim.read(sim.io().r.data), + r_data: ( + sim.read_bool_or_int(sim.io().r.data.0) + .to_bigint() + .try_into() + .expect("known to be in range"), + sim.read_bool_or_int(sim.io().r.data.1) + .to_bigint() + .try_into() + .expect("known to be in range"), + ), w_addr, w_en, w_data, @@ -730,11 +716,11 @@ fn test_memories() { String::from_utf8(writer.take()).unwrap(), ); sim.advance_time(SimDuration::from_micros(1)); - sim.write(sim.io().r.clk, true); - sim.write(sim.io().w.clk, true); + sim.write_clock(sim.io().r.clk, true); + sim.write_clock(sim.io().w.clk, true); sim.advance_time(SimDuration::from_micros(1)); - sim.write(sim.io().r.clk, false); - sim.write(sim.io().w.clk, false); + sim.write_clock(sim.io().r.clk, false); + sim.write_clock(sim.io().w.clk, false); } sim.flush_traces().unwrap(); let vcd = String::from_utf8(writer.take()).unwrap(); @@ -752,7 +738,7 @@ fn test_memories() { #[hdl_module(outline_generated)] pub fn memories2() { #[hdl] - let rw: ReadWriteStruct, ConstUsize<3>> = m.input(); + let rw: fayalite::memory::ReadWriteStruct, ConstUsize<3>> = m.input(); #[hdl] let mut mem = memory_with_init([HdlSome(true); 5]); mem.read_latency(1); @@ -1025,9 +1011,9 @@ fn test_memories2() { #[hdl_module(outline_generated)] pub fn memories3() { #[hdl] - let r: ReadStruct, 8>, ConstUsize<3>> = m.input(); + let r: fayalite::memory::ReadStruct, 8>, ConstUsize<3>> = m.input(); #[hdl] - let w: WriteStruct, 8>, ConstUsize<3>> = m.input(); + let w: fayalite::memory::WriteStruct, 8>, ConstUsize<3>> = m.input(); #[hdl] let mut mem: MemBuilder, 8>> = memory(); mem.depth(8); @@ -1546,83 +1532,3 @@ fn test_extern_module2() { panic!(); } } - -// use an extern module to simulate a register to test that the -// simulator can handle chains of alternating circuits and extern modules. -#[hdl_module(outline_generated, extern)] -pub fn sw_reg() { - #[hdl] - let clk: Clock = m.input(); - #[hdl] - let o: Bool = m.output(); - m.extern_module_simulation_fn((clk, o), |(clk, o), mut sim| async move { - let mut state = false; - loop { - sim.write(o, state).await; - sim.wait_for_clock_edge(clk).await; - state = !state; - } - }); -} - -#[hdl_module(outline_generated)] -pub fn ripple_counter() { - #[hdl] - let clk: Clock = m.input(); - #[hdl] - let o: UInt<6> = m.output(); - - #[hdl] - let bits: Array = wire(); - - connect_any(o, bits.cast_to_bits()); - - let mut clk_in = clk; - for (i, bit) in bits.into_iter().enumerate() { - if i % 2 == 0 { - let bit_reg = reg_builder_with_loc(&format!("bit_reg_{i}"), SourceLocation::caller()) - .clock_domain( - #[hdl] - ClockDomain { - clk: clk_in, - rst: false.to_sync_reset(), - }, - ) - .no_reset(Bool) - .build(); - connect(bit, bit_reg); - connect(bit_reg, !bit_reg); - } else { - let bit_reg = - instance_with_loc(&format!("bit_reg_{i}"), sw_reg(), SourceLocation::caller()); - connect(bit_reg.clk, clk_in); - connect(bit, bit_reg.o); - } - clk_in = bit.to_clock(); - } -} - -#[test] -fn test_ripple_counter() { - let _n = SourceLocation::normalize_files_for_tests(); - let mut sim = Simulation::new(ripple_counter()); - let mut writer = RcWriter::default(); - sim.add_trace_writer(VcdWriterDecls::new(writer.clone())); - for _ in 0..0x80 { - sim.write(sim.io().clk, false); - sim.advance_time(SimDuration::from_micros(1)); - sim.write(sim.io().clk, true); - sim.advance_time(SimDuration::from_micros(1)); - } - sim.flush_traces().unwrap(); - let vcd = String::from_utf8(writer.take()).unwrap(); - println!("####### VCD:\n{vcd}\n#######"); - if vcd != include_str!("sim/expected/ripple_counter.vcd") { - panic!(); - } - let sim_debug = format!("{sim:#?}"); - println!("#######\n{sim_debug}\n#######"); - if sim_debug != include_str!("sim/expected/ripple_counter.txt") { - panic!(); - } -} diff --git a/crates/fayalite/tests/sim/expected/enums.txt b/crates/fayalite/tests/sim/expected/enums.txt index 61ce5d5..089ea31 100644 --- a/crates/fayalite/tests/sim/expected/enums.txt +++ b/crates/fayalite/tests/sim/expected/enums.txt @@ -4,7 +4,7 @@ Simulation { state_layout: StateLayout { ty: TypeLayout { small_slots: StatePartLayout { - len: 7, + len: 6, debug_data: [ SlotDebugData { name: "", @@ -13,13 +13,6 @@ Simulation { HdlSome, }, }, - SlotDebugData { - name: "", - ty: Enum { - HdlNone, - HdlSome, - }, - }, SlotDebugData { name: "", ty: Bool, @@ -48,7 +41,7 @@ Simulation { .. }, big_slots: StatePartLayout { - len: 111, + len: 103, debug_data: [ SlotDebugData { name: "InstantiatedModule(enums: enums).enums::cd.clk", @@ -113,41 +106,6 @@ Simulation { name: "", ty: Bool, }, - SlotDebugData { - name: "InstantiatedModule(enums: enums).enums::b2_out", - ty: Enum { - HdlNone, - HdlSome(Bundle {0: UInt<1>, 1: Bool}), - }, - }, - SlotDebugData { - name: ".0", - ty: UInt<1>, - }, - SlotDebugData { - name: ".1", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: UInt<3>, - }, - SlotDebugData { - name: "", - ty: UInt<2>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: Bool, - }, SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum { @@ -540,640 +498,594 @@ Simulation { insns: [ // at: module-XXXXXXXXXX.rs:1:1 0: Const { - dest: StatePartIndex(98), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(90), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, value: 0x1, }, 1: Const { - dest: StatePartIndex(90), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(82), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, value: 0x0, }, 2: Const { - dest: StatePartIndex(88), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(80), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, value: 0x0, }, 3: Copy { - dest: StatePartIndex(89), // (0x0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - src: StatePartIndex(88), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(81), // (0x0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, + src: StatePartIndex(80), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, }, - // at: module-XXXXXXXXXX.rs:18:1 + // at: module-XXXXXXXXXX.rs:16:1 4: Copy { dest: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - src: StatePartIndex(89), // (0x0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, + src: StatePartIndex(81), // (0x0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, }, // at: module-XXXXXXXXXX.rs:1:1 5: SliceInt { - dest: StatePartIndex(77), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(69), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, src: StatePartIndex(4), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_in", ty: UInt<4> }, start: 2, len: 2, }, 6: CastToSInt { - dest: StatePartIndex(78), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, - src: StatePartIndex(77), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(70), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + src: StatePartIndex(69), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, dest_width: 2, }, 7: Const { - dest: StatePartIndex(70), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, value: 0x2, }, 8: SliceInt { - dest: StatePartIndex(57), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(49), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(4), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_in", ty: UInt<4> }, start: 1, len: 1, }, 9: Copy { - dest: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(57), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(50), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(49), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 10: Copy { - dest: StatePartIndex(76), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(68), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(50), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 11: SliceInt { - dest: StatePartIndex(54), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(46), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(4), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_in", ty: UInt<4> }, start: 0, len: 1, }, 12: Copy { - dest: StatePartIndex(55), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(54), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(46), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 13: Copy { - dest: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(55), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 14: Copy { - dest: StatePartIndex(52), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(44), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + src: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 15: Copy { - dest: StatePartIndex(53), // (0x1) SlotDebugData { name: ".1", ty: Bool }, - src: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(45), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + src: StatePartIndex(50), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 16: Copy { - dest: StatePartIndex(74), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, - src: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(66), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + src: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 17: Copy { - dest: StatePartIndex(75), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, - src: StatePartIndex(76), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(67), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + src: StatePartIndex(68), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 18: Copy { - dest: StatePartIndex(71), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, - src: StatePartIndex(74), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + dest: StatePartIndex(63), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + src: StatePartIndex(66), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, }, 19: Copy { - dest: StatePartIndex(72), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, - src: StatePartIndex(75), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + dest: StatePartIndex(64), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + src: StatePartIndex(67), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, }, 20: Copy { - dest: StatePartIndex(73), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, - src: StatePartIndex(78), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + dest: StatePartIndex(65), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + src: StatePartIndex(70), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, }, 21: Copy { - dest: StatePartIndex(66), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, - src: StatePartIndex(70), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(58), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, + src: StatePartIndex(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, 22: Copy { - dest: StatePartIndex(67), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, - src: StatePartIndex(71), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + dest: StatePartIndex(59), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, + src: StatePartIndex(63), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, }, 23: Copy { - dest: StatePartIndex(68), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, - src: StatePartIndex(72), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + dest: StatePartIndex(60), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, + src: StatePartIndex(64), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, }, 24: Copy { - dest: StatePartIndex(69), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, - src: StatePartIndex(73), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + dest: StatePartIndex(61), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, + src: StatePartIndex(65), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, }, 25: Shl { - dest: StatePartIndex(79), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(68), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, + dest: StatePartIndex(71), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(60), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, rhs: 1, }, 26: Or { - dest: StatePartIndex(80), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(67), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, - rhs: StatePartIndex(79), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(72), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(59), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, + rhs: StatePartIndex(71), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, 27: CastToUInt { - dest: StatePartIndex(81), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(69), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, + dest: StatePartIndex(73), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(61), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, dest_width: 2, }, 28: Shl { - dest: StatePartIndex(82), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(81), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(74), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(73), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 29: Or { - dest: StatePartIndex(83), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(80), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - rhs: StatePartIndex(82), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(75), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(72), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(74), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, }, 30: Shl { - dest: StatePartIndex(84), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, - lhs: StatePartIndex(83), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(76), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, + lhs: StatePartIndex(75), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, rhs: 2, }, 31: Or { - dest: StatePartIndex(85), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, - lhs: StatePartIndex(66), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, - rhs: StatePartIndex(84), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(77), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + lhs: StatePartIndex(58), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, + rhs: StatePartIndex(76), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, }, 32: CastToUInt { - dest: StatePartIndex(86), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, - src: StatePartIndex(85), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(78), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + src: StatePartIndex(77), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, dest_width: 6, }, 33: Copy { - dest: StatePartIndex(87), // (0x3e) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(86), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(79), // (0x3e) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(78), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, }, 34: Const { - dest: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, value: 0x1, }, 35: CmpEq { - dest: StatePartIndex(48), // (0x0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Bool }, lhs: StatePartIndex(3), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_in", ty: UInt<2> }, - rhs: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, }, 36: Copy { - dest: StatePartIndex(49), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, - src: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(41), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, + src: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, }, 37: Copy { - dest: StatePartIndex(50), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, - src: StatePartIndex(52), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + dest: StatePartIndex(42), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, + src: StatePartIndex(44), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, }, 38: Copy { - dest: StatePartIndex(51), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, - src: StatePartIndex(53), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + dest: StatePartIndex(43), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + src: StatePartIndex(45), // (0x1) SlotDebugData { name: ".1", ty: Bool }, }, 39: Copy { - dest: StatePartIndex(59), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(51), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + dest: StatePartIndex(51), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(43), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, }, 40: Shl { - dest: StatePartIndex(60), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(59), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(52), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(51), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, rhs: 1, }, 41: Or { - dest: StatePartIndex(61), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(50), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, - rhs: StatePartIndex(60), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(53), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(42), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, + rhs: StatePartIndex(52), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, 42: Shl { - dest: StatePartIndex(62), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(61), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(54), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(53), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 43: Or { - dest: StatePartIndex(63), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(49), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, - rhs: StatePartIndex(62), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(55), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(41), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, + rhs: StatePartIndex(54), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, }, 44: CastToUInt { - dest: StatePartIndex(64), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, - src: StatePartIndex(63), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(56), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, + src: StatePartIndex(55), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, dest_width: 6, }, 45: Copy { - dest: StatePartIndex(65), // (0xd) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(64), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(57), // (0xd) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(56), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, }, 46: Const { - dest: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, value: 0x0, }, 47: CmpEq { - dest: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(38), // (0x0) SlotDebugData { name: "", ty: Bool }, lhs: StatePartIndex(3), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_in", ty: UInt<2> }, - rhs: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, }, 48: Copy { - dest: StatePartIndex(29), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, - src: StatePartIndex(23), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + dest: StatePartIndex(21), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + src: StatePartIndex(15), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, }, 49: SliceInt { - dest: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(29), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(21), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, start: 2, len: 2, }, 50: SliceInt { - dest: StatePartIndex(31), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(23), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, 51: SliceInt { - dest: StatePartIndex(32), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(24), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, 52: Copy { - dest: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(32), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(25), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(24), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 53: Copy { - dest: StatePartIndex(27), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(31), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(19), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + src: StatePartIndex(23), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 54: Copy { - dest: StatePartIndex(28), // (0x1) SlotDebugData { name: ".1", ty: Bool }, - src: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(20), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + src: StatePartIndex(25), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 55: Copy { - dest: StatePartIndex(91), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(28), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + dest: StatePartIndex(83), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(20), // (0x1) SlotDebugData { name: ".1", ty: Bool }, }, 56: Shl { + dest: StatePartIndex(84), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(83), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + rhs: 1, + }, + 57: Or { + dest: StatePartIndex(85), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(19), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + rhs: StatePartIndex(84), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + }, + 58: CastToUInt { + dest: StatePartIndex(86), // (0x3) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(85), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest_width: 4, + }, + 59: Copy { + dest: StatePartIndex(87), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + src: StatePartIndex(90), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + }, + 60: Copy { + dest: StatePartIndex(88), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, + src: StatePartIndex(19), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + }, + 61: Copy { + dest: StatePartIndex(89), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + src: StatePartIndex(20), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + }, + 62: Copy { + dest: StatePartIndex(91), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(89), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + }, + 63: Shl { dest: StatePartIndex(92), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, lhs: StatePartIndex(91), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, rhs: 1, }, - 57: Or { + 64: Or { dest: StatePartIndex(93), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(27), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + lhs: StatePartIndex(88), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, rhs: StatePartIndex(92), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, - 58: CastToUInt { - dest: StatePartIndex(94), // (0x3) SlotDebugData { name: "", ty: UInt<4> }, - src: StatePartIndex(93), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - dest_width: 4, - }, - 59: Copy { - dest: StatePartIndex(95), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(98), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - }, - 60: Copy { - dest: StatePartIndex(96), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, - src: StatePartIndex(27), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - }, - 61: Copy { - dest: StatePartIndex(97), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, - src: StatePartIndex(28), // (0x1) SlotDebugData { name: ".1", ty: Bool }, - }, - 62: Copy { - dest: StatePartIndex(99), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(97), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, - }, - 63: Shl { - dest: StatePartIndex(100), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(99), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 1, - }, - 64: Or { - dest: StatePartIndex(101), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(96), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, - rhs: StatePartIndex(100), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - }, 65: Shl { - dest: StatePartIndex(102), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, - lhs: StatePartIndex(101), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(94), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, + lhs: StatePartIndex(93), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 1, }, 66: Or { - dest: StatePartIndex(103), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, - lhs: StatePartIndex(95), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - rhs: StatePartIndex(102), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(95), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + lhs: StatePartIndex(87), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + rhs: StatePartIndex(94), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, }, 67: CastToUInt { - dest: StatePartIndex(104), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, - src: StatePartIndex(103), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(96), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + src: StatePartIndex(95), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, dest_width: 3, }, 68: Copy { - dest: StatePartIndex(105), // (0x7) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - src: StatePartIndex(104), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(97), // (0x7) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, + src: StatePartIndex(96), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, }, 69: SliceInt { - dest: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, - src: StatePartIndex(29), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(21), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, start: 2, len: 4, }, 70: SliceInt { - dest: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, start: 0, len: 2, }, 71: SliceInt { - dest: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, 72: SliceInt { - dest: StatePartIndex(42), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(34), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, 73: Copy { - dest: StatePartIndex(37), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, - src: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(29), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + src: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 74: Copy { - dest: StatePartIndex(38), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, - src: StatePartIndex(42), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(30), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + src: StatePartIndex(34), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 75: SliceInt { - dest: StatePartIndex(43), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(35), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, start: 2, len: 2, }, 76: CastToSInt { - dest: StatePartIndex(44), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, - src: StatePartIndex(43), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(36), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + src: StatePartIndex(35), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, dest_width: 2, }, 77: Copy { - dest: StatePartIndex(34), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, - src: StatePartIndex(37), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + dest: StatePartIndex(26), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + src: StatePartIndex(29), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, }, 78: Copy { - dest: StatePartIndex(35), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, - src: StatePartIndex(38), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + dest: StatePartIndex(27), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + src: StatePartIndex(30), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, }, 79: Copy { - dest: StatePartIndex(36), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, - src: StatePartIndex(44), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + dest: StatePartIndex(28), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + src: StatePartIndex(36), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, }, 80: Shl { - dest: StatePartIndex(106), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(35), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + dest: StatePartIndex(98), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(27), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, rhs: 1, }, 81: Or { - dest: StatePartIndex(107), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(34), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, - rhs: StatePartIndex(106), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(99), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(26), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + rhs: StatePartIndex(98), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, 82: CastToUInt { - dest: StatePartIndex(108), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(36), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + dest: StatePartIndex(100), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(28), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, dest_width: 2, }, 83: Shl { - dest: StatePartIndex(109), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(108), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(101), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(100), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 84: Or { - dest: StatePartIndex(110), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(107), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - rhs: StatePartIndex(109), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(102), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(99), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(101), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, }, - // at: module-XXXXXXXXXX.rs:11:1 + // at: module-XXXXXXXXXX.rs:9:1 85: AndBigWithSmallImmediate { - dest: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, - lhs: StatePartIndex(23), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + dest: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + lhs: StatePartIndex(15), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, rhs: 0x3, }, - // at: module-XXXXXXXXXX.rs:19:1 + // at: module-XXXXXXXXXX.rs:17:1 86: BranchIfSmallNeImmediate { target: 89, - lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, rhs: 0x0, }, - // at: module-XXXXXXXXXX.rs:20:1 + // at: module-XXXXXXXXXX.rs:18:1 87: Copy { dest: StatePartIndex(5), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_out", ty: UInt<2> }, - src: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, }, - // at: module-XXXXXXXXXX.rs:21:1 + // at: module-XXXXXXXXXX.rs:19:1 88: Copy { dest: StatePartIndex(6), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_out", ty: UInt<4> }, - src: StatePartIndex(90), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(82), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, }, - // at: module-XXXXXXXXXX.rs:19:1 + // at: module-XXXXXXXXXX.rs:17:1 89: BranchIfSmallNeImmediate { target: 93, - lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, rhs: 0x1, }, - // at: module-XXXXXXXXXX.rs:22:1 + // at: module-XXXXXXXXXX.rs:20:1 90: Copy { dest: StatePartIndex(5), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_out", ty: UInt<2> }, - src: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, }, - // at: module-XXXXXXXXXX.rs:23:1 + // at: module-XXXXXXXXXX.rs:21:1 91: Copy { dest: StatePartIndex(6), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_out", ty: UInt<4> }, - src: StatePartIndex(94), // (0x3) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(86), // (0x3) SlotDebugData { name: "", ty: UInt<4> }, }, - // at: module-XXXXXXXXXX.rs:24:1 + // at: module-XXXXXXXXXX.rs:22:1 92: Copy { dest: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - src: StatePartIndex(105), // (0x7) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, + src: StatePartIndex(97), // (0x7) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, }, - // at: module-XXXXXXXXXX.rs:19:1 + // at: module-XXXXXXXXXX.rs:17:1 93: BranchIfSmallNeImmediate { target: 96, - lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, rhs: 0x2, }, - // at: module-XXXXXXXXXX.rs:25:1 + // at: module-XXXXXXXXXX.rs:23:1 94: Copy { dest: StatePartIndex(5), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_out", ty: UInt<2> }, - src: StatePartIndex(70), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, - // at: module-XXXXXXXXXX.rs:26:1 + // at: module-XXXXXXXXXX.rs:24:1 95: Copy { dest: StatePartIndex(6), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_out", ty: UInt<4> }, - src: StatePartIndex(110), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(102), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, }, - // at: module-XXXXXXXXXX.rs:11:1 + // at: module-XXXXXXXXXX.rs:9:1 96: IsNonZeroDestIsSmall { - dest: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, src: StatePartIndex(1), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::cd.rst", ty: SyncReset }, }, // at: module-XXXXXXXXXX.rs:1:1 97: Const { - dest: StatePartIndex(25), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(17), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, value: 0x0, }, 98: Copy { - dest: StatePartIndex(26), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(25), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(17), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, }, - // at: module-XXXXXXXXXX.rs:12:1 + // at: module-XXXXXXXXXX.rs:10:1 99: BranchIfZero { target: 107, value: StatePartIndex(2), // (0x1) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::en", ty: Bool }, }, - // at: module-XXXXXXXXXX.rs:13:1 + // at: module-XXXXXXXXXX.rs:11:1 100: BranchIfZero { target: 102, - value: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Bool }, + value: StatePartIndex(38), // (0x0) SlotDebugData { name: "", ty: Bool }, }, - // at: module-XXXXXXXXXX.rs:14:1 + // at: module-XXXXXXXXXX.rs:12:1 101: Copy { - dest: StatePartIndex(24), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(26), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - }, - // at: module-XXXXXXXXXX.rs:13:1 - 102: BranchIfNonZero { - target: 107, - value: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:15:1 - 103: BranchIfZero { - target: 105, - value: StatePartIndex(48), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:16:1 - 104: Copy { - dest: StatePartIndex(24), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(65), // (0xd) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - }, - // at: module-XXXXXXXXXX.rs:15:1 - 105: BranchIfNonZero { - target: 107, - value: StatePartIndex(48), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:17:1 - 106: Copy { - dest: StatePartIndex(24), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(87), // (0x3e) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + dest: StatePartIndex(16), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, }, // at: module-XXXXXXXXXX.rs:11:1 + 102: BranchIfNonZero { + target: 107, + value: StatePartIndex(38), // (0x0) SlotDebugData { name: "", ty: Bool }, + }, + // at: module-XXXXXXXXXX.rs:13:1 + 103: BranchIfZero { + target: 105, + value: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Bool }, + }, + // at: module-XXXXXXXXXX.rs:14:1 + 104: Copy { + dest: StatePartIndex(16), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(57), // (0xd) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + }, + // at: module-XXXXXXXXXX.rs:13:1 + 105: BranchIfNonZero { + target: 107, + value: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Bool }, + }, + // at: module-XXXXXXXXXX.rs:15:1 + 106: Copy { + dest: StatePartIndex(16), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(79), // (0x3e) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + }, + // at: module-XXXXXXXXXX.rs:9:1 107: IsNonZeroDestIsSmall { - dest: StatePartIndex(4), // (0x1 1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, src: StatePartIndex(0), // (0x1) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::cd.clk", ty: Clock }, }, 108: AndSmall { - dest: StatePartIndex(3), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(4), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - rhs: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + lhs: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, + rhs: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Bool }, }, - // at: module-XXXXXXXXXX.rs:10:1 + // at: module-XXXXXXXXXX.rs:1:1 109: Copy { - dest: StatePartIndex(15), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b2_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - src: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 110: Copy { - dest: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - src: StatePartIndex(15), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b2_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - }, - 111: SliceInt { - dest: StatePartIndex(19), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - start: 1, - len: 2, - }, - 112: SliceInt { - dest: StatePartIndex(20), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(19), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - start: 0, - len: 1, - }, - 113: SliceInt { - dest: StatePartIndex(21), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(19), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - start: 1, - len: 1, - }, - 114: Copy { - dest: StatePartIndex(22), // (0x0) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(21), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - }, - 115: Copy { - dest: StatePartIndex(16), // (0x0) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(20), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - }, - 116: Copy { - dest: StatePartIndex(17), // (0x0) SlotDebugData { name: ".1", ty: Bool }, - src: StatePartIndex(22), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:9:1 - 117: AndBigWithSmallImmediate { - dest: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome} }, - lhs: StatePartIndex(15), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b2_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - rhs: 0x1, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 118: Copy { dest: StatePartIndex(10), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, src: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, }, - 119: SliceInt { + 110: SliceInt { dest: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, src: StatePartIndex(10), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, start: 1, len: 2, }, - 120: SliceInt { + 111: SliceInt { dest: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, - 121: SliceInt { + 112: SliceInt { dest: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, - 122: Copy { + 113: Copy { dest: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: Bool }, src: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, }, - 123: Copy { + 114: Copy { dest: StatePartIndex(8), // (0x0) SlotDebugData { name: ".0", ty: UInt<1> }, src: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, }, - 124: Copy { + 115: Copy { dest: StatePartIndex(9), // (0x0) SlotDebugData { name: ".1", ty: Bool }, src: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: Bool }, }, // at: module-XXXXXXXXXX.rs:8:1 - 125: AndBigWithSmallImmediate { + 116: AndBigWithSmallImmediate { dest: StatePartIndex(0), // (0x0 0) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome} }, lhs: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::b_out", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, rhs: 0x1, }, - // at: module-XXXXXXXXXX.rs:11:1 - 126: BranchIfSmallZero { - target: 131, - value: StatePartIndex(3), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + // at: module-XXXXXXXXXX.rs:9:1 + 117: BranchIfSmallZero { + target: 122, + value: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, }, - 127: BranchIfSmallNonZero { - target: 130, - value: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + 118: BranchIfSmallNonZero { + target: 121, + value: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, }, - 128: Copy { - dest: StatePartIndex(23), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(24), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + 119: Copy { + dest: StatePartIndex(15), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(16), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg$next", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, }, - 129: Branch { - target: 131, + 120: Branch { + target: 122, }, - 130: Copy { - dest: StatePartIndex(23), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, - src: StatePartIndex(26), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + 121: Copy { + dest: StatePartIndex(15), // (0x3e) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::the_reg", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, + src: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: Enum {A, B(Bundle {0: UInt<1>, 1: Bool}), C(Bundle {a: Array, 2>, b: SInt<2>})} }, }, - 131: XorSmallImmediate { - dest: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(4), // (0x1 1) SlotDebugData { name: "", ty: Bool }, + 122: XorSmallImmediate { + dest: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + lhs: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, rhs: 0x1, }, // at: module-XXXXXXXXXX.rs:1:1 - 132: Return, + 123: Return, ], .. }, - pc: 132, + pc: 123, memory_write_log: [], memories: StatePart { value: [], @@ -1183,7 +1095,6 @@ Simulation { 0, 0, 0, - 0, 1, 0, 2, @@ -1206,14 +1117,6 @@ Simulation { 0, 0, 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, 62, 62, 0, @@ -1363,23 +1266,9 @@ Simulation { .. }, }.b_out, - Instance { - name: ::enums, - instantiated: Module { - name: enums, - .. - }, - }.b2_out, ], uninitialized_ios: {}, io_targets: { - Instance { - name: ::enums, - instantiated: Module { - name: enums, - .. - }, - }.b2_out, Instance { name: ::enums, instantiated: Module { @@ -1587,22 +1476,23 @@ Simulation { }, flow: Sink, }, - TraceModuleIO { - name: "b2_out", + TraceReg { + name: "the_reg", child: TraceEnumWithFields { - name: "b2_out", + name: "the_reg", discriminant: TraceEnumDiscriminant { location: TraceScalarId(10), name: "$tag", ty: Enum { - HdlNone, - HdlSome(Bundle {0: UInt<1>, 1: Bool}), + A, + B(Bundle {0: UInt<1>, 1: Bool}), + C(Bundle {a: Array, 2>, b: SInt<2>}), }, - flow: Sink, + flow: Duplex, }, non_empty_fields: [ TraceBundle { - name: "HdlSome", + name: "B", fields: [ TraceUInt { location: TraceScalarId(11), @@ -1624,57 +1514,6 @@ Simulation { }, flow: Source, }, - ], - ty: Enum { - HdlNone, - HdlSome(Bundle {0: UInt<1>, 1: Bool}), - }, - flow: Sink, - }, - ty: Enum { - HdlNone, - HdlSome(Bundle {0: UInt<1>, 1: Bool}), - }, - flow: Sink, - }, - TraceReg { - name: "the_reg", - child: TraceEnumWithFields { - name: "the_reg", - discriminant: TraceEnumDiscriminant { - location: TraceScalarId(13), - name: "$tag", - ty: Enum { - A, - B(Bundle {0: UInt<1>, 1: Bool}), - C(Bundle {a: Array, 2>, b: SInt<2>}), - }, - flow: Duplex, - }, - non_empty_fields: [ - TraceBundle { - name: "B", - fields: [ - TraceUInt { - location: TraceScalarId(14), - name: "0", - ty: UInt<1>, - flow: Source, - }, - TraceBool { - location: TraceScalarId(15), - name: "1", - flow: Source, - }, - ], - ty: Bundle { - /* offset = 0 */ - 0: UInt<1>, - /* offset = 1 */ - 1: Bool, - }, - flow: Source, - }, TraceBundle { name: "C", fields: [ @@ -1682,13 +1521,13 @@ Simulation { name: "a", elements: [ TraceUInt { - location: TraceScalarId(16), + location: TraceScalarId(13), name: "[0]", ty: UInt<1>, flow: Source, }, TraceUInt { - location: TraceScalarId(17), + location: TraceScalarId(14), name: "[1]", ty: UInt<1>, flow: Source, @@ -1698,7 +1537,7 @@ Simulation { flow: Source, }, TraceSInt { - location: TraceScalarId(18), + location: TraceScalarId(15), name: "b", ty: SInt<2>, flow: Source, @@ -1821,36 +1660,7 @@ Simulation { SimTrace { id: TraceScalarId(10), kind: EnumDiscriminant { - index: StatePartIndex(1), - ty: Enum { - HdlNone, - HdlSome(Bundle {0: UInt<1>, 1: Bool}), - }, - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(11), - kind: BigUInt { - index: StatePartIndex(16), - ty: UInt<1>, - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(12), - kind: BigBool { - index: StatePartIndex(17), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(13), - kind: EnumDiscriminant { - index: StatePartIndex(6), + index: StatePartIndex(5), ty: Enum { A, B(Bundle {0: UInt<1>, 1: Bool}), @@ -1860,6 +1670,32 @@ Simulation { state: 0x2, last_state: 0x2, }, + SimTrace { + id: TraceScalarId(11), + kind: BigUInt { + index: StatePartIndex(19), + ty: UInt<1>, + }, + state: 0x1, + last_state: 0x1, + }, + SimTrace { + id: TraceScalarId(12), + kind: BigBool { + index: StatePartIndex(20), + }, + state: 0x1, + last_state: 0x1, + }, + SimTrace { + id: TraceScalarId(13), + kind: BigUInt { + index: StatePartIndex(26), + ty: UInt<1>, + }, + state: 0x1, + last_state: 0x1, + }, SimTrace { id: TraceScalarId(14), kind: BigUInt { @@ -1871,34 +1707,8 @@ Simulation { }, SimTrace { id: TraceScalarId(15), - kind: BigBool { - index: StatePartIndex(28), - }, - state: 0x1, - last_state: 0x1, - }, - SimTrace { - id: TraceScalarId(16), - kind: BigUInt { - index: StatePartIndex(34), - ty: UInt<1>, - }, - state: 0x1, - last_state: 0x1, - }, - SimTrace { - id: TraceScalarId(17), - kind: BigUInt { - index: StatePartIndex(35), - ty: UInt<1>, - }, - state: 0x1, - last_state: 0x1, - }, - SimTrace { - id: TraceScalarId(18), kind: BigSInt { - index: StatePartIndex(36), + index: StatePartIndex(28), ty: SInt<2>, }, state: 0x3, @@ -1917,7 +1727,7 @@ Simulation { ], instant: 16 μs, clocks_triggered: [ - StatePartIndex(3), + StatePartIndex(2), ], .. } \ No newline at end of file diff --git a/crates/fayalite/tests/sim/expected/enums.vcd b/crates/fayalite/tests/sim/expected/enums.vcd index aff867b..07cbd32 100644 --- a/crates/fayalite/tests/sim/expected/enums.vcd +++ b/crates/fayalite/tests/sim/expected/enums.vcd @@ -16,25 +16,18 @@ $var wire 1 ) \0 $end $var wire 1 * \1 $end $upscope $end $upscope $end -$scope struct b2_out $end -$var string 1 + \$tag $end -$scope struct HdlSome $end -$var wire 1 , \0 $end -$var wire 1 - \1 $end -$upscope $end -$upscope $end $scope struct the_reg $end -$var string 1 . \$tag $end +$var string 1 + \$tag $end $scope struct B $end -$var reg 1 / \0 $end -$var reg 1 0 \1 $end +$var reg 1 , \0 $end +$var reg 1 - \1 $end $upscope $end $scope struct C $end $scope struct a $end -$var reg 1 1 \[0] $end -$var reg 1 2 \[1] $end +$var reg 1 . \[0] $end +$var reg 1 / \[1] $end $upscope $end -$var reg 2 3 b $end +$var reg 2 0 b $end $upscope $end $upscope $end $upscope $end @@ -50,15 +43,12 @@ b0 ' sHdlNone\x20(0) ( 0) 0* -sHdlNone\x20(0) + +sA\x20(0) + 0, 0- -sA\x20(0) . +0. 0/ -00 -01 -02 -b0 3 +b0 0 $end #1000000 1! @@ -76,8 +66,7 @@ b1 $ 1! b1 & sHdlSome\x20(1) ( -sHdlSome\x20(1) + -sB\x20(1) . +sB\x20(1) + #6000000 0# b0 $ @@ -96,10 +85,8 @@ b11 ' 1* 1, 1- +1. 1/ -10 -11 -12 #10000000 0! #11000000 @@ -114,11 +101,8 @@ b1111 ' sHdlNone\x20(0) ( 0) 0* -sHdlNone\x20(0) + -0, -0- -sC\x20(2) . -b11 3 +sC\x20(2) + +b11 0 #14000000 0! #15000000 diff --git a/crates/fayalite/tests/sim/expected/extern_module2.txt b/crates/fayalite/tests/sim/expected/extern_module2.txt index ec842ff..96710fb 100644 --- a/crates/fayalite/tests/sim/expected/extern_module2.txt +++ b/crates/fayalite/tests/sim/expected/extern_module2.txt @@ -222,9 +222,7 @@ Simulation { }, value: SimValue { ty: Clock, - value: OpaqueSimValue { - bits: 0x1_u1, - }, + bits: 0x1, }, }, }, diff --git a/crates/fayalite/tests/sim/expected/ripple_counter.txt b/crates/fayalite/tests/sim/expected/ripple_counter.txt deleted file mode 100644 index 5472950..0000000 --- a/crates/fayalite/tests/sim/expected/ripple_counter.txt +++ /dev/null @@ -1,1498 +0,0 @@ -Simulation { - state: State { - insns: Insns { - state_layout: StateLayout { - ty: TypeLayout { - small_slots: StatePartLayout { - len: 9, - debug_data: [ - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - ], - .. - }, - big_slots: StatePartLayout { - len: 58, - debug_data: [ - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::o", - ty: UInt<6>, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[0]", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[1]", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[2]", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[3]", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[4]", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[5]", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<2>, - }, - SlotDebugData { - name: "", - ty: UInt<2>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<3>, - }, - SlotDebugData { - name: "", - ty: UInt<3>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<4>, - }, - SlotDebugData { - name: "", - ty: UInt<4>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<5>, - }, - SlotDebugData { - name: "", - ty: UInt<5>, - }, - SlotDebugData { - name: "", - ty: UInt<1>, - }, - SlotDebugData { - name: "", - ty: UInt<6>, - }, - SlotDebugData { - name: "", - ty: UInt<6>, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0$next", - ty: Bool, - }, - SlotDebugData { - name: ".clk", - ty: Clock, - }, - SlotDebugData { - name: ".rst", - ty: SyncReset, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: SyncReset, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.o", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::o", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2$next", - ty: Bool, - }, - SlotDebugData { - name: ".clk", - ty: Clock, - }, - SlotDebugData { - name: ".rst", - ty: SyncReset, - }, - SlotDebugData { - name: "", - ty: Clock, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.o", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::o", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4$next", - ty: Bool, - }, - SlotDebugData { - name: ".clk", - ty: Clock, - }, - SlotDebugData { - name: ".rst", - ty: SyncReset, - }, - SlotDebugData { - name: "", - ty: Clock, - }, - SlotDebugData { - name: "", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.o", - ty: Bool, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk", - ty: Clock, - }, - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::o", - ty: Bool, - }, - SlotDebugData { - name: "", - ty: Clock, - }, - ], - .. - }, - }, - memories: StatePartLayout { - len: 0, - debug_data: [], - layout_data: [], - .. - }, - }, - insns: [ - // at: module-XXXXXXXXXX.rs:9:1 - 0: Copy { - dest: StatePartIndex(54), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.o", ty: Bool }, - src: StatePartIndex(56), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:11:1 - 1: Copy { - dest: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[5]", ty: Bool }, - src: StatePartIndex(54), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 2: NotU { - dest: StatePartIndex(52), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(47), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4", ty: Bool }, - width: 1, - }, - // at: module-XXXXXXXXXX.rs:8:1 - 3: Copy { - dest: StatePartIndex(48), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4$next", ty: Bool }, - src: StatePartIndex(52), // (0x1) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:7:1 - 4: Copy { - dest: StatePartIndex(6), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[4]", ty: Bool }, - src: StatePartIndex(47), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 5: Copy { - dest: StatePartIndex(57), // (0x0) SlotDebugData { name: "", ty: Clock }, - src: StatePartIndex(6), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[4]", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:10:1 - 6: Copy { - dest: StatePartIndex(53), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.clk", ty: Clock }, - src: StatePartIndex(57), // (0x0) SlotDebugData { name: "", ty: Clock }, - }, - // at: module-XXXXXXXXXX.rs:9:1 - 7: Copy { - dest: StatePartIndex(55), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk", ty: Clock }, - src: StatePartIndex(53), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_5.clk", ty: Clock }, - }, - 8: Copy { - dest: StatePartIndex(43), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.o", ty: Bool }, - src: StatePartIndex(45), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:11:1 - 9: Copy { - dest: StatePartIndex(5), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[3]", ty: Bool }, - src: StatePartIndex(43), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 10: Copy { - dest: StatePartIndex(51), // (0x0) SlotDebugData { name: "", ty: Clock }, - src: StatePartIndex(5), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[3]", ty: Bool }, - }, - 11: NotU { - dest: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(36), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2", ty: Bool }, - width: 1, - }, - // at: module-XXXXXXXXXX.rs:8:1 - 12: Copy { - dest: StatePartIndex(37), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2$next", ty: Bool }, - src: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:7:1 - 13: Copy { - dest: StatePartIndex(4), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[2]", ty: Bool }, - src: StatePartIndex(36), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 14: Copy { - dest: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Clock }, - src: StatePartIndex(4), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[2]", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:10:1 - 15: Copy { - dest: StatePartIndex(42), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.clk", ty: Clock }, - src: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Clock }, - }, - // at: module-XXXXXXXXXX.rs:9:1 - 16: Copy { - dest: StatePartIndex(44), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk", ty: Clock }, - src: StatePartIndex(42), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_3.clk", ty: Clock }, - }, - 17: Copy { - dest: StatePartIndex(32), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.o", ty: Bool }, - src: StatePartIndex(34), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:11:1 - 18: Copy { - dest: StatePartIndex(3), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[1]", ty: Bool }, - src: StatePartIndex(32), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.o", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 19: Copy { - dest: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Clock }, - src: StatePartIndex(3), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[1]", ty: Bool }, - }, - 20: NotU { - dest: StatePartIndex(30), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(24), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0", ty: Bool }, - width: 1, - }, - // at: module-XXXXXXXXXX.rs:8:1 - 21: Copy { - dest: StatePartIndex(25), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0$next", ty: Bool }, - src: StatePartIndex(30), // (0x1) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:7:1 - 22: Copy { - dest: StatePartIndex(2), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[0]", ty: Bool }, - src: StatePartIndex(24), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 23: Copy { - dest: StatePartIndex(35), // (0x0) SlotDebugData { name: "", ty: Clock }, - src: StatePartIndex(2), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[0]", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:10:1 - 24: Copy { - dest: StatePartIndex(31), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.clk", ty: Clock }, - src: StatePartIndex(35), // (0x0) SlotDebugData { name: "", ty: Clock }, - }, - // at: module-XXXXXXXXXX.rs:9:1 - 25: Copy { - dest: StatePartIndex(33), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk", ty: Clock }, - src: StatePartIndex(31), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_1.clk", ty: Clock }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 26: Const { - dest: StatePartIndex(28), // (0x0) SlotDebugData { name: "", ty: Bool }, - value: 0x0, - }, - 27: Copy { - dest: StatePartIndex(29), // (0x0) SlotDebugData { name: "", ty: SyncReset }, - src: StatePartIndex(28), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - 28: Copy { - dest: StatePartIndex(26), // (0x1) SlotDebugData { name: ".clk", ty: Clock }, - src: StatePartIndex(0), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::clk", ty: Clock }, - }, - 29: Copy { - dest: StatePartIndex(27), // (0x0) SlotDebugData { name: ".rst", ty: SyncReset }, - src: StatePartIndex(29), // (0x0) SlotDebugData { name: "", ty: SyncReset }, - }, - // at: module-XXXXXXXXXX.rs:6:1 - 30: IsNonZeroDestIsSmall { - dest: StatePartIndex(2), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(26), // (0x1) SlotDebugData { name: ".clk", ty: Clock }, - }, - 31: AndSmall { - dest: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(2), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - rhs: StatePartIndex(0), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 32: Copy { - dest: StatePartIndex(38), // (0x0) SlotDebugData { name: ".clk", ty: Clock }, - src: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Clock }, - }, - 33: Copy { - dest: StatePartIndex(39), // (0x0) SlotDebugData { name: ".rst", ty: SyncReset }, - src: StatePartIndex(29), // (0x0) SlotDebugData { name: "", ty: SyncReset }, - }, - // at: module-XXXXXXXXXX.rs:6:1 - 34: IsNonZeroDestIsSmall { - dest: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(38), // (0x0) SlotDebugData { name: ".clk", ty: Clock }, - }, - 35: AndSmall { - dest: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - rhs: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 36: Copy { - dest: StatePartIndex(49), // (0x0) SlotDebugData { name: ".clk", ty: Clock }, - src: StatePartIndex(51), // (0x0) SlotDebugData { name: "", ty: Clock }, - }, - 37: Copy { - dest: StatePartIndex(50), // (0x0) SlotDebugData { name: ".rst", ty: SyncReset }, - src: StatePartIndex(29), // (0x0) SlotDebugData { name: "", ty: SyncReset }, - }, - // at: module-XXXXXXXXXX.rs:6:1 - 38: IsNonZeroDestIsSmall { - dest: StatePartIndex(8), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(49), // (0x0) SlotDebugData { name: ".clk", ty: Clock }, - }, - 39: AndSmall { - dest: StatePartIndex(7), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(8), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - rhs: StatePartIndex(6), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 40: Copy { - dest: StatePartIndex(21), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(7), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[5]", ty: Bool }, - }, - 41: Shl { - dest: StatePartIndex(22), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, - lhs: StatePartIndex(21), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 5, - }, - 42: Copy { - dest: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(6), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[4]", ty: Bool }, - }, - 43: Shl { - dest: StatePartIndex(19), // (0x0) SlotDebugData { name: "", ty: UInt<5> }, - lhs: StatePartIndex(18), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 4, - }, - 44: Copy { - dest: StatePartIndex(15), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(5), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[3]", ty: Bool }, - }, - 45: Shl { - dest: StatePartIndex(16), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(15), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 3, - }, - 46: Copy { - dest: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(4), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[2]", ty: Bool }, - }, - 47: Shl { - dest: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - lhs: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 2, - }, - 48: Copy { - dest: StatePartIndex(9), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(3), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[1]", ty: Bool }, - }, - 49: Shl { - dest: StatePartIndex(10), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(9), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: 1, - }, - 50: Copy { - dest: StatePartIndex(8), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(2), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bits[0]", ty: Bool }, - }, - 51: Or { - dest: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(8), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, - rhs: StatePartIndex(10), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - }, - 52: Or { - dest: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - lhs: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - rhs: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - }, - 53: Or { - dest: StatePartIndex(17), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, - rhs: StatePartIndex(16), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, - }, - 54: Or { - dest: StatePartIndex(20), // (0x0) SlotDebugData { name: "", ty: UInt<5> }, - lhs: StatePartIndex(17), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, - rhs: StatePartIndex(19), // (0x0) SlotDebugData { name: "", ty: UInt<5> }, - }, - 55: Or { - dest: StatePartIndex(23), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, - lhs: StatePartIndex(20), // (0x0) SlotDebugData { name: "", ty: UInt<5> }, - rhs: StatePartIndex(22), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, - }, - // at: module-XXXXXXXXXX.rs:5:1 - 56: Copy { - dest: StatePartIndex(1), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::o", ty: UInt<6> }, - src: StatePartIndex(23), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, - }, - // at: module-XXXXXXXXXX.rs:6:1 - 57: BranchIfSmallZero { - target: 59, - value: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - }, - 58: Copy { - dest: StatePartIndex(24), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0", ty: Bool }, - src: StatePartIndex(25), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_0$next", ty: Bool }, - }, - 59: BranchIfSmallZero { - target: 61, - value: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - }, - 60: Copy { - dest: StatePartIndex(36), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2", ty: Bool }, - src: StatePartIndex(37), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_2$next", ty: Bool }, - }, - 61: BranchIfSmallZero { - target: 63, - value: StatePartIndex(7), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - }, - 62: Copy { - dest: StatePartIndex(47), // (0x0) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4", ty: Bool }, - src: StatePartIndex(48), // (0x1) SlotDebugData { name: "InstantiatedModule(ripple_counter: ripple_counter).ripple_counter::bit_reg_4$next", ty: Bool }, - }, - 63: XorSmallImmediate { - dest: StatePartIndex(0), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(2), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - rhs: 0x1, - }, - 64: XorSmallImmediate { - dest: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - rhs: 0x1, - }, - 65: XorSmallImmediate { - dest: StatePartIndex(6), // (0x1 1) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(8), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - rhs: 0x1, - }, - // at: module-XXXXXXXXXX.rs:1:1 - 66: Return, - ], - .. - }, - pc: 66, - memory_write_log: [], - memories: StatePart { - value: [], - }, - small_slots: StatePart { - value: [ - 0, - 0, - 1, - 1, - 0, - 0, - 1, - 0, - 0, - ], - }, - big_slots: StatePart { - value: [ - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 1, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 0, - ], - }, - }, - io: Instance { - name: ::ripple_counter, - instantiated: Module { - name: ripple_counter, - .. - }, - }, - main_module: SimulationModuleState { - base_targets: [ - Instance { - name: ::ripple_counter, - instantiated: Module { - name: ripple_counter, - .. - }, - }.clk, - Instance { - name: ::ripple_counter, - instantiated: Module { - name: ripple_counter, - .. - }, - }.o, - ], - uninitialized_ios: {}, - io_targets: { - Instance { - name: ::ripple_counter, - instantiated: Module { - name: ripple_counter, - .. - }, - }.clk, - Instance { - name: ::ripple_counter, - instantiated: Module { - name: ripple_counter, - .. - }, - }.o, - }, - did_initial_settle: true, - }, - extern_modules: [ - SimulationExternModuleState { - module_state: SimulationModuleState { - base_targets: [ - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ], - uninitialized_ios: {}, - io_targets: { - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - }, - did_initial_settle: true, - }, - sim: ExternModuleSimulation { - generator: SimGeneratorFn { - args: ( - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ), - f: ..., - }, - source_location: SourceLocation( - module-XXXXXXXXXX-2.rs:4:1, - ), - }, - running_generator: Some( - ..., - ), - wait_targets: { - Change { - key: CompiledValue { - layout: CompiledTypeLayout { - ty: Clock, - layout: TypeLayout { - small_slots: StatePartLayout { - len: 0, - debug_data: [], - .. - }, - big_slots: StatePartLayout { - len: 1, - debug_data: [ - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk", - ty: Clock, - }, - ], - .. - }, - }, - body: Scalar, - }, - range: TypeIndexRange { - small_slots: StatePartIndexRange { start: 3, len: 0 }, - big_slots: StatePartIndexRange { start: 33, len: 1 }, - }, - write: None, - }, - value: SimValue { - ty: Clock, - value: OpaqueSimValue { - bits: 0x0_u1, - }, - }, - }, - }, - }, - SimulationExternModuleState { - module_state: SimulationModuleState { - base_targets: [ - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ], - uninitialized_ios: {}, - io_targets: { - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - }, - did_initial_settle: true, - }, - sim: ExternModuleSimulation { - generator: SimGeneratorFn { - args: ( - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ), - f: ..., - }, - source_location: SourceLocation( - module-XXXXXXXXXX-2.rs:4:1, - ), - }, - running_generator: Some( - ..., - ), - wait_targets: { - Change { - key: CompiledValue { - layout: CompiledTypeLayout { - ty: Clock, - layout: TypeLayout { - small_slots: StatePartLayout { - len: 0, - debug_data: [], - .. - }, - big_slots: StatePartLayout { - len: 1, - debug_data: [ - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk", - ty: Clock, - }, - ], - .. - }, - }, - body: Scalar, - }, - range: TypeIndexRange { - small_slots: StatePartIndexRange { start: 6, len: 0 }, - big_slots: StatePartIndexRange { start: 44, len: 1 }, - }, - write: None, - }, - value: SimValue { - ty: Clock, - value: OpaqueSimValue { - bits: 0x0_u1, - }, - }, - }, - }, - }, - SimulationExternModuleState { - module_state: SimulationModuleState { - base_targets: [ - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ], - uninitialized_ios: {}, - io_targets: { - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - }, - did_initial_settle: true, - }, - sim: ExternModuleSimulation { - generator: SimGeneratorFn { - args: ( - ModuleIO { - name: sw_reg::clk, - is_input: true, - ty: Clock, - .. - }, - ModuleIO { - name: sw_reg::o, - is_input: false, - ty: Bool, - .. - }, - ), - f: ..., - }, - source_location: SourceLocation( - module-XXXXXXXXXX-2.rs:4:1, - ), - }, - running_generator: Some( - ..., - ), - wait_targets: { - Change { - key: CompiledValue { - layout: CompiledTypeLayout { - ty: Clock, - layout: TypeLayout { - small_slots: StatePartLayout { - len: 0, - debug_data: [], - .. - }, - big_slots: StatePartLayout { - len: 1, - debug_data: [ - SlotDebugData { - name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk", - ty: Clock, - }, - ], - .. - }, - }, - body: Scalar, - }, - range: TypeIndexRange { - small_slots: StatePartIndexRange { start: 9, len: 0 }, - big_slots: StatePartIndexRange { start: 55, len: 1 }, - }, - write: None, - }, - value: SimValue { - ty: Clock, - value: OpaqueSimValue { - bits: 0x0_u1, - }, - }, - }, - }, - }, - ], - state_ready_to_run: false, - trace_decls: TraceModule { - name: "ripple_counter", - children: [ - TraceModuleIO { - name: "clk", - child: TraceClock { - location: TraceScalarId(0), - name: "clk", - flow: Source, - }, - ty: Clock, - flow: Source, - }, - TraceModuleIO { - name: "o", - child: TraceUInt { - location: TraceScalarId(1), - name: "o", - ty: UInt<6>, - flow: Sink, - }, - ty: UInt<6>, - flow: Sink, - }, - TraceWire { - name: "bits", - child: TraceArray { - name: "bits", - elements: [ - TraceBool { - location: TraceScalarId(2), - name: "[0]", - flow: Duplex, - }, - TraceBool { - location: TraceScalarId(3), - name: "[1]", - flow: Duplex, - }, - TraceBool { - location: TraceScalarId(4), - name: "[2]", - flow: Duplex, - }, - TraceBool { - location: TraceScalarId(5), - name: "[3]", - flow: Duplex, - }, - TraceBool { - location: TraceScalarId(6), - name: "[4]", - flow: Duplex, - }, - TraceBool { - location: TraceScalarId(7), - name: "[5]", - flow: Duplex, - }, - ], - ty: Array, - flow: Duplex, - }, - ty: Array, - }, - TraceReg { - name: "bit_reg_0", - child: TraceBool { - location: TraceScalarId(8), - name: "bit_reg_0", - flow: Duplex, - }, - ty: Bool, - }, - TraceInstance { - name: "bit_reg_1", - instance_io: TraceBundle { - name: "bit_reg_1", - fields: [ - TraceClock { - location: TraceScalarId(11), - name: "clk", - flow: Sink, - }, - TraceBool { - location: TraceScalarId(12), - name: "o", - flow: Source, - }, - ], - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - flow: Source, - }, - module: TraceModule { - name: "sw_reg", - children: [ - TraceModuleIO { - name: "clk", - child: TraceClock { - location: TraceScalarId(9), - name: "clk", - flow: Source, - }, - ty: Clock, - flow: Source, - }, - TraceModuleIO { - name: "o", - child: TraceBool { - location: TraceScalarId(10), - name: "o", - flow: Sink, - }, - ty: Bool, - flow: Sink, - }, - ], - }, - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - }, - TraceReg { - name: "bit_reg_2", - child: TraceBool { - location: TraceScalarId(13), - name: "bit_reg_2", - flow: Duplex, - }, - ty: Bool, - }, - TraceInstance { - name: "bit_reg_3", - instance_io: TraceBundle { - name: "bit_reg_3", - fields: [ - TraceClock { - location: TraceScalarId(16), - name: "clk", - flow: Sink, - }, - TraceBool { - location: TraceScalarId(17), - name: "o", - flow: Source, - }, - ], - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - flow: Source, - }, - module: TraceModule { - name: "sw_reg", - children: [ - TraceModuleIO { - name: "clk", - child: TraceClock { - location: TraceScalarId(14), - name: "clk", - flow: Source, - }, - ty: Clock, - flow: Source, - }, - TraceModuleIO { - name: "o", - child: TraceBool { - location: TraceScalarId(15), - name: "o", - flow: Sink, - }, - ty: Bool, - flow: Sink, - }, - ], - }, - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - }, - TraceReg { - name: "bit_reg_4", - child: TraceBool { - location: TraceScalarId(18), - name: "bit_reg_4", - flow: Duplex, - }, - ty: Bool, - }, - TraceInstance { - name: "bit_reg_5", - instance_io: TraceBundle { - name: "bit_reg_5", - fields: [ - TraceClock { - location: TraceScalarId(21), - name: "clk", - flow: Sink, - }, - TraceBool { - location: TraceScalarId(22), - name: "o", - flow: Source, - }, - ], - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - flow: Source, - }, - module: TraceModule { - name: "sw_reg", - children: [ - TraceModuleIO { - name: "clk", - child: TraceClock { - location: TraceScalarId(19), - name: "clk", - flow: Source, - }, - ty: Clock, - flow: Source, - }, - TraceModuleIO { - name: "o", - child: TraceBool { - location: TraceScalarId(20), - name: "o", - flow: Sink, - }, - ty: Bool, - flow: Sink, - }, - ], - }, - ty: Bundle { - #[hdl(flip)] /* offset = 0 */ - clk: Clock, - /* offset = 1 */ - o: Bool, - }, - }, - ], - }, - traces: [ - SimTrace { - id: TraceScalarId(0), - kind: BigClock { - index: StatePartIndex(0), - }, - state: 0x1, - last_state: 0x1, - }, - SimTrace { - id: TraceScalarId(1), - kind: BigUInt { - index: StatePartIndex(1), - ty: UInt<6>, - }, - state: 0x00, - last_state: 0x00, - }, - SimTrace { - id: TraceScalarId(2), - kind: BigBool { - index: StatePartIndex(2), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(3), - kind: BigBool { - index: StatePartIndex(3), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(4), - kind: BigBool { - index: StatePartIndex(4), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(5), - kind: BigBool { - index: StatePartIndex(5), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(6), - kind: BigBool { - index: StatePartIndex(6), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(7), - kind: BigBool { - index: StatePartIndex(7), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(8), - kind: BigBool { - index: StatePartIndex(24), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(9), - kind: BigClock { - index: StatePartIndex(33), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(10), - kind: BigBool { - index: StatePartIndex(34), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(11), - kind: BigClock { - index: StatePartIndex(31), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(12), - kind: BigBool { - index: StatePartIndex(32), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(13), - kind: BigBool { - index: StatePartIndex(36), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(14), - kind: BigClock { - index: StatePartIndex(44), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(15), - kind: BigBool { - index: StatePartIndex(45), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(16), - kind: BigClock { - index: StatePartIndex(42), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(17), - kind: BigBool { - index: StatePartIndex(43), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(18), - kind: BigBool { - index: StatePartIndex(47), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(19), - kind: BigClock { - index: StatePartIndex(55), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(20), - kind: BigBool { - index: StatePartIndex(56), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(21), - kind: BigClock { - index: StatePartIndex(53), - }, - state: 0x0, - last_state: 0x0, - }, - SimTrace { - id: TraceScalarId(22), - kind: BigBool { - index: StatePartIndex(54), - }, - state: 0x0, - last_state: 0x0, - }, - ], - trace_memories: {}, - trace_writers: [ - Running( - VcdWriter { - finished_init: true, - timescale: 1 ps, - .. - }, - ), - ], - instant: 256 μs, - clocks_triggered: [ - StatePartIndex(1), - StatePartIndex(4), - StatePartIndex(7), - ], - .. -} \ No newline at end of file diff --git a/crates/fayalite/tests/sim/expected/ripple_counter.vcd b/crates/fayalite/tests/sim/expected/ripple_counter.vcd deleted file mode 100644 index 6f14a8e..0000000 --- a/crates/fayalite/tests/sim/expected/ripple_counter.vcd +++ /dev/null @@ -1,1753 +0,0 @@ -$timescale 1 ps $end -$scope module ripple_counter $end -$var wire 1 ! clk $end -$var wire 6 " o $end -$scope struct bits $end -$var wire 1 # \[0] $end -$var wire 1 $ \[1] $end -$var wire 1 % \[2] $end -$var wire 1 & \[3] $end -$var wire 1 ' \[4] $end -$var wire 1 ( \[5] $end -$upscope $end -$var reg 1 ) bit_reg_0 $end -$scope struct bit_reg_1 $end -$var wire 1 , clk $end -$var wire 1 - o $end -$upscope $end -$scope module sw_reg $end -$var wire 1 * clk $end -$var wire 1 + o $end -$upscope $end -$var reg 1 . bit_reg_2 $end -$scope struct bit_reg_3 $end -$var wire 1 1 clk $end -$var wire 1 2 o $end -$upscope $end -$scope module sw_reg_2 $end -$var wire 1 / clk $end -$var wire 1 0 o $end -$upscope $end -$var reg 1 3 bit_reg_4 $end -$scope struct bit_reg_5 $end -$var wire 1 6 clk $end -$var wire 1 7 o $end -$upscope $end -$scope module sw_reg_3 $end -$var wire 1 4 clk $end -$var wire 1 5 o $end -$upscope $end -$upscope $end -$enddefinitions $end -$dumpvars -0! -b0 " -0# -0$ -0% -0& -0' -0( -0) -0* -0+ -0, -0- -0. -0/ -00 -01 -02 -03 -04 -05 -06 -07 -$end -#1000000 -1! -1) -b1 " -1# -1* -1, -1+ -b11 " -1$ -1- -1. -b111 " -1% -1/ -11 -10 -b1111 " -1& -12 -13 -b11111 " -1' -14 -16 -15 -b111111 " -1( -17 -#2000000 -0! -#3000000 -1! -0) -b111110 " -0# -0* -0, -#4000000 -0! -#5000000 -1! -1) -b111111 " -1# -1* -1, -0+ -b111101 " -0$ -0- -#6000000 -0! -#7000000 -1! -0) -b111100 " -0# -0* -0, -#8000000 -0! -#9000000 -1! -1) -b111101 " -1# -1* -1, -1+ -b111111 " -1$ -1- -0. -b111011 " -0% -0/ -01 -#10000000 -0! -#11000000 -1! -0) -b111010 " -0# -0* -0, -#12000000 -0! -#13000000 -1! -1) -b111011 " -1# -1* -1, -0+ -b111001 " -0$ -0- -#14000000 -0! -#15000000 -1! -0) -b111000 " -0# -0* -0, -#16000000 -0! -#17000000 -1! -1) -b111001 " -1# -1* -1, -1+ -b111011 " -1$ -1- -1. -b111111 " -1% -1/ -11 -00 -b110111 " -0& -02 -#18000000 -0! -#19000000 -1! -0) -b110110 " -0# -0* -0, -#20000000 -0! -#21000000 -1! -1) -b110111 " -1# -1* -1, -0+ -b110101 " -0$ -0- -#22000000 -0! -#23000000 -1! -0) -b110100 " -0# -0* -0, -#24000000 -0! -#25000000 -1! -1) -b110101 " -1# -1* -1, -1+ -b110111 " -1$ -1- -0. -b110011 " -0% -0/ -01 -#26000000 -0! -#27000000 -1! -0) -b110010 " -0# -0* -0, -#28000000 -0! -#29000000 -1! -1) -b110011 " -1# -1* -1, -0+ -b110001 " -0$ -0- -#30000000 -0! -#31000000 -1! -0) -b110000 " -0# -0* -0, -#32000000 -0! -#33000000 -1! -1) -b110001 " -1# -1* -1, -1+ -b110011 " -1$ -1- -1. -b110111 " -1% -1/ -11 -10 -b111111 " -1& -12 -03 -b101111 " -0' -04 -06 -#34000000 -0! -#35000000 -1! -0) -b101110 " -0# -0* -0, -#36000000 -0! -#37000000 -1! -1) -b101111 " -1# -1* -1, -0+ -b101101 " -0$ -0- -#38000000 -0! -#39000000 -1! -0) -b101100 " -0# -0* -0, -#40000000 -0! -#41000000 -1! -1) -b101101 " -1# -1* -1, -1+ -b101111 " -1$ -1- -0. -b101011 " -0% -0/ -01 -#42000000 -0! -#43000000 -1! -0) -b101010 " -0# -0* -0, -#44000000 -0! -#45000000 -1! -1) -b101011 " -1# -1* -1, -0+ -b101001 " -0$ -0- -#46000000 -0! -#47000000 -1! -0) -b101000 " -0# -0* -0, -#48000000 -0! -#49000000 -1! -1) -b101001 " -1# -1* -1, -1+ -b101011 " -1$ -1- -1. -b101111 " -1% -1/ -11 -00 -b100111 " -0& -02 -#50000000 -0! -#51000000 -1! -0) -b100110 " -0# -0* -0, -#52000000 -0! -#53000000 -1! -1) -b100111 " -1# -1* -1, -0+ -b100101 " -0$ -0- -#54000000 -0! -#55000000 -1! -0) -b100100 " -0# -0* -0, -#56000000 -0! -#57000000 -1! -1) -b100101 " -1# -1* -1, -1+ -b100111 " -1$ -1- -0. -b100011 " -0% -0/ -01 -#58000000 -0! -#59000000 -1! -0) -b100010 " -0# -0* -0, -#60000000 -0! -#61000000 -1! -1) -b100011 " -1# -1* -1, -0+ -b100001 " -0$ -0- -#62000000 -0! -#63000000 -1! -0) -b100000 " -0# -0* -0, -#64000000 -0! -#65000000 -1! -1) -b100001 " -1# -1* -1, -1+ -b100011 " -1$ -1- -1. -b100111 " -1% -1/ -11 -10 -b101111 " -1& -12 -13 -b111111 " -1' -14 -16 -05 -b11111 " -0( -07 -#66000000 -0! -#67000000 -1! -0) -b11110 " -0# -0* -0, -#68000000 -0! -#69000000 -1! -1) -b11111 " -1# -1* -1, -0+ -b11101 " -0$ -0- -#70000000 -0! -#71000000 -1! -0) -b11100 " -0# -0* -0, -#72000000 -0! -#73000000 -1! -1) -b11101 " -1# -1* -1, -1+ -b11111 " -1$ -1- -0. -b11011 " -0% -0/ -01 -#74000000 -0! -#75000000 -1! -0) -b11010 " -0# -0* -0, -#76000000 -0! -#77000000 -1! -1) -b11011 " -1# -1* -1, -0+ -b11001 " -0$ -0- -#78000000 -0! -#79000000 -1! -0) -b11000 " -0# -0* -0, -#80000000 -0! -#81000000 -1! -1) -b11001 " -1# -1* -1, -1+ -b11011 " -1$ -1- -1. -b11111 " -1% -1/ -11 -00 -b10111 " -0& -02 -#82000000 -0! -#83000000 -1! -0) -b10110 " -0# -0* -0, -#84000000 -0! -#85000000 -1! -1) -b10111 " -1# -1* -1, -0+ -b10101 " -0$ -0- -#86000000 -0! -#87000000 -1! -0) -b10100 " -0# -0* -0, -#88000000 -0! -#89000000 -1! -1) -b10101 " -1# -1* -1, -1+ -b10111 " -1$ -1- -0. -b10011 " -0% -0/ -01 -#90000000 -0! -#91000000 -1! -0) -b10010 " -0# -0* -0, -#92000000 -0! -#93000000 -1! -1) -b10011 " -1# -1* -1, -0+ -b10001 " -0$ -0- -#94000000 -0! -#95000000 -1! -0) -b10000 " -0# -0* -0, -#96000000 -0! -#97000000 -1! -1) -b10001 " -1# -1* -1, -1+ -b10011 " -1$ -1- -1. -b10111 " -1% -1/ -11 -10 -b11111 " -1& -12 -03 -b1111 " -0' -04 -06 -#98000000 -0! -#99000000 -1! -0) -b1110 " -0# -0* -0, -#100000000 -0! -#101000000 -1! -1) -b1111 " -1# -1* -1, -0+ -b1101 " -0$ -0- -#102000000 -0! -#103000000 -1! -0) -b1100 " -0# -0* -0, -#104000000 -0! -#105000000 -1! -1) -b1101 " -1# -1* -1, -1+ -b1111 " -1$ -1- -0. -b1011 " -0% -0/ -01 -#106000000 -0! -#107000000 -1! -0) -b1010 " -0# -0* -0, -#108000000 -0! -#109000000 -1! -1) -b1011 " -1# -1* -1, -0+ -b1001 " -0$ -0- -#110000000 -0! -#111000000 -1! -0) -b1000 " -0# -0* -0, -#112000000 -0! -#113000000 -1! -1) -b1001 " -1# -1* -1, -1+ -b1011 " -1$ -1- -1. -b1111 " -1% -1/ -11 -00 -b111 " -0& -02 -#114000000 -0! -#115000000 -1! -0) -b110 " -0# -0* -0, -#116000000 -0! -#117000000 -1! -1) -b111 " -1# -1* -1, -0+ -b101 " -0$ -0- -#118000000 -0! -#119000000 -1! -0) -b100 " -0# -0* -0, -#120000000 -0! -#121000000 -1! -1) -b101 " -1# -1* -1, -1+ -b111 " -1$ -1- -0. -b11 " -0% -0/ -01 -#122000000 -0! -#123000000 -1! -0) -b10 " -0# -0* -0, -#124000000 -0! -#125000000 -1! -1) -b11 " -1# -1* -1, -0+ -b1 " -0$ -0- -#126000000 -0! -#127000000 -1! -0) -b0 " -0# -0* -0, -#128000000 -0! -#129000000 -1! -1) -b1 " -1# -1* -1, -1+ -b11 " -1$ -1- -1. -b111 " -1% -1/ -11 -10 -b1111 " -1& -12 -13 -b11111 " -1' -14 -16 -15 -b111111 " -1( -17 -#130000000 -0! -#131000000 -1! -0) -b111110 " -0# -0* -0, -#132000000 -0! -#133000000 -1! -1) -b111111 " -1# -1* -1, -0+ -b111101 " -0$ -0- -#134000000 -0! -#135000000 -1! -0) -b111100 " -0# -0* -0, -#136000000 -0! -#137000000 -1! -1) -b111101 " -1# -1* -1, -1+ -b111111 " -1$ -1- -0. -b111011 " -0% -0/ -01 -#138000000 -0! -#139000000 -1! -0) -b111010 " -0# -0* -0, -#140000000 -0! -#141000000 -1! -1) -b111011 " -1# -1* -1, -0+ -b111001 " -0$ -0- -#142000000 -0! -#143000000 -1! -0) -b111000 " -0# -0* -0, -#144000000 -0! -#145000000 -1! -1) -b111001 " -1# -1* -1, -1+ -b111011 " -1$ -1- -1. -b111111 " -1% -1/ -11 -00 -b110111 " -0& -02 -#146000000 -0! -#147000000 -1! -0) -b110110 " -0# -0* -0, -#148000000 -0! -#149000000 -1! -1) -b110111 " -1# -1* -1, -0+ -b110101 " -0$ -0- -#150000000 -0! -#151000000 -1! -0) -b110100 " -0# -0* -0, -#152000000 -0! -#153000000 -1! -1) -b110101 " -1# -1* -1, -1+ -b110111 " -1$ -1- -0. -b110011 " -0% -0/ -01 -#154000000 -0! -#155000000 -1! -0) -b110010 " -0# -0* -0, -#156000000 -0! -#157000000 -1! -1) -b110011 " -1# -1* -1, -0+ -b110001 " -0$ -0- -#158000000 -0! -#159000000 -1! -0) -b110000 " -0# -0* -0, -#160000000 -0! -#161000000 -1! -1) -b110001 " -1# -1* -1, -1+ -b110011 " -1$ -1- -1. -b110111 " -1% -1/ -11 -10 -b111111 " -1& -12 -03 -b101111 " -0' -04 -06 -#162000000 -0! -#163000000 -1! -0) -b101110 " -0# -0* -0, -#164000000 -0! -#165000000 -1! -1) -b101111 " -1# -1* -1, -0+ -b101101 " -0$ -0- -#166000000 -0! -#167000000 -1! -0) -b101100 " -0# -0* -0, -#168000000 -0! -#169000000 -1! -1) -b101101 " -1# -1* -1, -1+ -b101111 " -1$ -1- -0. -b101011 " -0% -0/ -01 -#170000000 -0! -#171000000 -1! -0) -b101010 " -0# -0* -0, -#172000000 -0! -#173000000 -1! -1) -b101011 " -1# -1* -1, -0+ -b101001 " -0$ -0- -#174000000 -0! -#175000000 -1! -0) -b101000 " -0# -0* -0, -#176000000 -0! -#177000000 -1! -1) -b101001 " -1# -1* -1, -1+ -b101011 " -1$ -1- -1. -b101111 " -1% -1/ -11 -00 -b100111 " -0& -02 -#178000000 -0! -#179000000 -1! -0) -b100110 " -0# -0* -0, -#180000000 -0! -#181000000 -1! -1) -b100111 " -1# -1* -1, -0+ -b100101 " -0$ -0- -#182000000 -0! -#183000000 -1! -0) -b100100 " -0# -0* -0, -#184000000 -0! -#185000000 -1! -1) -b100101 " -1# -1* -1, -1+ -b100111 " -1$ -1- -0. -b100011 " -0% -0/ -01 -#186000000 -0! -#187000000 -1! -0) -b100010 " -0# -0* -0, -#188000000 -0! -#189000000 -1! -1) -b100011 " -1# -1* -1, -0+ -b100001 " -0$ -0- -#190000000 -0! -#191000000 -1! -0) -b100000 " -0# -0* -0, -#192000000 -0! -#193000000 -1! -1) -b100001 " -1# -1* -1, -1+ -b100011 " -1$ -1- -1. -b100111 " -1% -1/ -11 -10 -b101111 " -1& -12 -13 -b111111 " -1' -14 -16 -05 -b11111 " -0( -07 -#194000000 -0! -#195000000 -1! -0) -b11110 " -0# -0* -0, -#196000000 -0! -#197000000 -1! -1) -b11111 " -1# -1* -1, -0+ -b11101 " -0$ -0- -#198000000 -0! -#199000000 -1! -0) -b11100 " -0# -0* -0, -#200000000 -0! -#201000000 -1! -1) -b11101 " -1# -1* -1, -1+ -b11111 " -1$ -1- -0. -b11011 " -0% -0/ -01 -#202000000 -0! -#203000000 -1! -0) -b11010 " -0# -0* -0, -#204000000 -0! -#205000000 -1! -1) -b11011 " -1# -1* -1, -0+ -b11001 " -0$ -0- -#206000000 -0! -#207000000 -1! -0) -b11000 " -0# -0* -0, -#208000000 -0! -#209000000 -1! -1) -b11001 " -1# -1* -1, -1+ -b11011 " -1$ -1- -1. -b11111 " -1% -1/ -11 -00 -b10111 " -0& -02 -#210000000 -0! -#211000000 -1! -0) -b10110 " -0# -0* -0, -#212000000 -0! -#213000000 -1! -1) -b10111 " -1# -1* -1, -0+ -b10101 " -0$ -0- -#214000000 -0! -#215000000 -1! -0) -b10100 " -0# -0* -0, -#216000000 -0! -#217000000 -1! -1) -b10101 " -1# -1* -1, -1+ -b10111 " -1$ -1- -0. -b10011 " -0% -0/ -01 -#218000000 -0! -#219000000 -1! -0) -b10010 " -0# -0* -0, -#220000000 -0! -#221000000 -1! -1) -b10011 " -1# -1* -1, -0+ -b10001 " -0$ -0- -#222000000 -0! -#223000000 -1! -0) -b10000 " -0# -0* -0, -#224000000 -0! -#225000000 -1! -1) -b10001 " -1# -1* -1, -1+ -b10011 " -1$ -1- -1. -b10111 " -1% -1/ -11 -10 -b11111 " -1& -12 -03 -b1111 " -0' -04 -06 -#226000000 -0! -#227000000 -1! -0) -b1110 " -0# -0* -0, -#228000000 -0! -#229000000 -1! -1) -b1111 " -1# -1* -1, -0+ -b1101 " -0$ -0- -#230000000 -0! -#231000000 -1! -0) -b1100 " -0# -0* -0, -#232000000 -0! -#233000000 -1! -1) -b1101 " -1# -1* -1, -1+ -b1111 " -1$ -1- -0. -b1011 " -0% -0/ -01 -#234000000 -0! -#235000000 -1! -0) -b1010 " -0# -0* -0, -#236000000 -0! -#237000000 -1! -1) -b1011 " -1# -1* -1, -0+ -b1001 " -0$ -0- -#238000000 -0! -#239000000 -1! -0) -b1000 " -0# -0* -0, -#240000000 -0! -#241000000 -1! -1) -b1001 " -1# -1* -1, -1+ -b1011 " -1$ -1- -1. -b1111 " -1% -1/ -11 -00 -b111 " -0& -02 -#242000000 -0! -#243000000 -1! -0) -b110 " -0# -0* -0, -#244000000 -0! -#245000000 -1! -1) -b111 " -1# -1* -1, -0+ -b101 " -0$ -0- -#246000000 -0! -#247000000 -1! -0) -b100 " -0# -0* -0, -#248000000 -0! -#249000000 -1! -1) -b101 " -1# -1* -1, -1+ -b111 " -1$ -1- -0. -b11 " -0% -0/ -01 -#250000000 -0! -#251000000 -1! -0) -b10 " -0# -0* -0, -#252000000 -0! -#253000000 -1! -1) -b11 " -1# -1* -1, -0+ -b1 " -0$ -0- -#254000000 -0! -#255000000 -1! -0) -b0 " -0# -0* -0, -#256000000