From ec3a61513ba0b3a4b8db7026bac7bc6beb0a1eaa Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Thu, 27 Mar 2025 23:03:44 -0700 Subject: [PATCH 1/7] simulator read/write types must be passive --- crates/fayalite/src/sim.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs index 275b106..b508756 100644 --- a/crates/fayalite/src/sim.rs +++ b/crates/fayalite/src/sim.rs @@ -6698,6 +6698,11 @@ 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; } -- 2.43.6 From e0f978fbb6b9ce19876489d0bbe5fcdae57175a3 Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Thu, 27 Mar 2025 23:17:28 -0700 Subject: [PATCH 2/7] silence unused `m` variable warning in #[hdl_module] with an empty body. --- crates/fayalite-proc-macros-impl/src/module.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/crates/fayalite-proc-macros-impl/src/module.rs b/crates/fayalite-proc-macros-impl/src/module.rs index 0852f58..62b7837 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, - block, + mut block, struct_generics, the_struct, } = match self.0 { @@ -439,6 +439,12 @@ 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, -- 2.43.6 From 5028401a5adad671f31ab754a958a692debdb062 Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Thu, 27 Mar 2025 23:44:36 -0700 Subject: [PATCH 3/7] change SimValue to contain and deref to a value and not just contain bits --- .../src/hdl_bundle.rs | 171 ++++- .../fayalite-proc-macros-impl/src/hdl_enum.rs | 269 +++++++ crates/fayalite/src/array.rs | 55 ++ crates/fayalite/src/bundle.rs | 191 ++++- crates/fayalite/src/clock.rs | 17 + crates/fayalite/src/enum_.rs | 327 ++++++++- crates/fayalite/src/expr.rs | 1 + crates/fayalite/src/int.rs | 68 +- crates/fayalite/src/lib.rs | 2 + crates/fayalite/src/phantom_const.rs | 23 + crates/fayalite/src/reset.rs | 17 + crates/fayalite/src/sim.rs | 674 +----------------- crates/fayalite/src/sim/value.rs | 665 +++++++++++++++++ crates/fayalite/src/ty.rs | 52 +- crates/fayalite/src/util.rs | 1 + crates/fayalite/src/util/alternating_cell.rs | 122 ++++ crates/fayalite/tests/sim.rs | 214 +++--- .../tests/sim/expected/extern_module2.txt | 4 +- .../tests/sim/expected/ripple_counter.txt | 12 +- 19 files changed, 2065 insertions(+), 820 deletions(-) create mode 100644 crates/fayalite/src/sim/value.rs create mode 100644 crates/fayalite/src/util/alternating_cell.rs diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs index b0fe498..a083def 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs @@ -30,7 +30,9 @@ 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, } @@ -125,7 +127,9 @@ 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, @@ -427,7 +431,9 @@ 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; @@ -523,7 +529,7 @@ impl ToTokens for ParsedBundle { semi_token: None, } .to_tokens(tokens); - let mut mask_type_match_variant_fields = mask_type_fields; + let mut mask_type_match_variant_fields = mask_type_fields.clone(); for Field { ty, .. } in &mut mask_type_match_variant_fields.named { *ty = parse_quote_spanned! {span=> ::fayalite::expr::Expr<#ty> @@ -565,6 +571,58 @@ 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); @@ -615,6 +673,25 @@ 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 fields_len = fields.named().into_iter().len(); quote_spanned! {span=> #[automatically_derived] @@ -623,6 +700,7 @@ 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< @@ -660,6 +738,34 @@ 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 @@ -696,6 +802,7 @@ impl ToTokens for ParsedBundle { { 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< @@ -735,6 +842,34 @@ 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 @@ -768,23 +903,33 @@ impl ToTokens for ParsedBundle { } .to_tokens(tokens); if let Some((cmp_eq,)) = cmp_eq { - let mut where_clause = + let mut expr_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(); - where_clause + expr_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) }); @@ -792,9 +937,13 @@ 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) }; @@ -802,6 +951,9 @@ 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)&* }; @@ -812,7 +964,7 @@ impl ToTokens for ParsedBundle { quote_spanned! {span=> #[automatically_derived] impl #impl_generics ::fayalite::expr::ops::ExprPartialEq for #target #type_generics - #where_clause + #expr_where_clause { fn cmp_eq( __lhs: ::fayalite::expr::Expr, @@ -827,6 +979,17 @@ 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); } diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index 9174566..0cdf85c 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -129,6 +129,7 @@ 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, } impl ParsedEnum { @@ -190,6 +191,7 @@ impl ParsedEnum { brace_token, variants, match_variant_ident: format_ident!("__{}__MatchVariant", ident), + sim_value_ident: format_ident!("__{}__SimValue", ident), ident, }) } @@ -207,6 +209,7 @@ impl ToTokens for ParsedEnum { brace_token, variants, match_variant_ident, + sim_value_ident, } = self; let span = ident.span(); let ItemOptions { @@ -409,6 +412,106 @@ impl ToTokens for ParsedEnum { )), } .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 { @@ -534,6 +637,142 @@ 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] @@ -542,6 +781,7 @@ 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; @@ -574,6 +814,35 @@ 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 diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs index 0d9b63f..a2df6cf 100644 --- a/crates/fayalite/src/array.rs +++ b/crates/fayalite/src/array.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information +use bitvec::slice::BitSlice; + use crate::{ expr::{ ops::{ArrayLiteral, ExprFromIterator, ExprIntoIterator, ExprPartialEq}, @@ -9,6 +11,7 @@ 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::{ CanonicalType, MatchVariantWithoutScope, StaticType, Type, TypeProperties, TypeWithDeref, @@ -142,6 +145,7 @@ 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>; @@ -178,9 +182,48 @@ 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 TypeWithDeref for ArrayType { @@ -247,6 +290,18 @@ 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 9807b92..06e0411 100644 --- a/crates/fayalite/src/bundle.rs +++ b/crates/fayalite/src/bundle.rs @@ -8,14 +8,14 @@ use crate::{ }, int::{Bool, DynSize}, intern::{Intern, Interned}, - sim::{SimValue, ToSimValue}, + sim::value::{SimValue, SimValuePartialEq, ToSimValue}, source_location::SourceLocation, ty::{ - impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, StaticType, Type, - TypeProperties, TypeWithDeref, + impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, + StaticType, Type, TypeProperties, TypeWithDeref, }, }; -use bitvec::vec::BitVec; +use bitvec::{slice::BitSlice, vec::BitVec}; use hashbrown::HashMap; use std::{fmt, marker::PhantomData}; @@ -216,6 +216,7 @@ 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( @@ -239,6 +240,20 @@ 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 { @@ -247,6 +262,93 @@ 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; @@ -353,6 +455,7 @@ 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; @@ -391,6 +494,24 @@ 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>,)*)>; @@ -444,16 +565,12 @@ macro_rules! impl_tuples { impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { #[track_caller] fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - ToSimValue::::to_sim_value(self, Bundle::from_canonical(ty)).into_canonical() + SimValue::into_canonical(ToSimValue::::to_sim_value(self, Bundle::from_canonical(ty))) } #[track_caller] fn into_sim_value(self, ty: CanonicalType) -> SimValue { - 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() + SimValue::into_canonical(ToSimValue::::into_sim_value(self, Bundle::from_canonical(ty))) } } impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { @@ -474,24 +591,12 @@ macro_rules! impl_tuples { let [$($ty_var,)*] = *ty.fields() else { panic!("bundle has wrong number of fields"); }; - let mut bits: Option = None; + let mut bits = BitVec::new(); $(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); - } - } + assert_eq!(SimValue::ty(&$var), $ty_var.ty); + bits.extend_from_bitslice(SimValue::bits(&$var).bits()); )* - 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) + bits.into_sim_value(ty) } } impl<$($T: ToSimValue<$Ty>, $Ty: Type,)*> ToSimValue<($($Ty,)*)> for ($($T,)*) { @@ -499,19 +604,15 @@ macro_rules! impl_tuples { fn to_sim_value(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.to_sim_value($ty_var).into_canonical();)* - SimValue::from_canonical(ToSimValue::into_sim_value(($($var,)*), ty.canonical())) + $(let $var = $var.to_sim_value($ty_var);)* + SimValue::from_value(ty, ($($var,)*)) } #[track_caller] fn into_sim_value(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.into_sim_value($ty_var).into_canonical();)* - SimValue::from_canonical(ToSimValue::into_sim_value(($($var,)*), ty.canonical())) - } - #[track_caller] - fn box_into_sim_value(self: Box, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { - Self::into_sim_value(*self, ty) + $(let $var = $var.into_sim_value($ty_var);)* + SimValue::from_value(ty, ($($var,)*)) } } impl<$($Lhs: Type + ExprPartialEq<$Rhs>, $Rhs: Type,)*> ExprPartialEq<($($Rhs,)*)> for ($($Lhs,)*) { @@ -537,6 +638,15 @@ 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)*] []); @@ -564,6 +674,7 @@ impl_tuples! { impl Type for PhantomData { type BaseType = Bundle; type MaskType = (); + type SimValue = (); type MatchVariant = PhantomData; type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope; @@ -596,6 +707,16 @@ impl Type for PhantomData { fn source_location() -> SourceLocation { SourceLocation::builtin() } + fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { + assert!(bits.is_empty()); + () + } + 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); @@ -663,6 +784,6 @@ impl ToSimValue for PhantomData { fn to_sim_value(&self, ty: CanonicalType) -> SimValue { let ty = Bundle::from_canonical(ty); assert!(ty.fields().is_empty()); - ToSimValue::into_sim_value(BitVec::new(), ty).into_canonical() + SimValue::into_canonical(ToSimValue::into_sim_value(BitVec::new(), ty)) } } diff --git a/crates/fayalite/src/clock.rs b/crates/fayalite/src/clock.rs index 711432b..f0623d4 100644 --- a/crates/fayalite/src/clock.rs +++ b/crates/fayalite/src/clock.rs @@ -8,6 +8,7 @@ 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; @@ -15,6 +16,7 @@ pub struct Clock; impl Type for Clock { type BaseType = Clock; type MaskType = Bool; + type SimValue = bool; impl_match_variant_as_self!(); @@ -36,6 +38,21 @@ 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 70c58c0..9fa38e9 100644 --- a/crates/fayalite/src/enum_.rs +++ b/crates/fayalite/src/enum_.rs @@ -7,17 +7,22 @@ use crate::{ Expr, ToExpr, }, hdl, - int::Bool, + int::{Bool, UIntValue}, 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, StaticType, Type, TypeProperties}, + ty::{ + CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, StaticType, Type, + TypeProperties, + }, }; +use bitvec::{order::Lsb0, slice::BitSlice, view::BitView}; use hashbrown::HashMap; -use std::{convert::Infallible, fmt, iter::FusedIterator}; +use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc}; #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct EnumVariant { @@ -152,6 +157,12 @@ 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, @@ -325,6 +336,7 @@ 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; @@ -355,6 +367,296 @@ 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 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()); + } } #[hdl] @@ -417,6 +719,25 @@ 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 016ec8e..f511c97 100644 --- a/crates/fayalite/src/expr.rs +++ b/crates/fayalite/src/expr.rs @@ -700,6 +700,7 @@ 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 236f240..a956dd5 100644 --- a/crates/fayalite/src/int.rs +++ b/crates/fayalite/src/int.rs @@ -7,6 +7,7 @@ use crate::{ Expr, NotALiteralExpr, ToExpr, ToLiteralBits, }, intern::{Intern, Interned, Memoize}, + sim::value::SimValue, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize}, @@ -49,6 +50,15 @@ pub trait KnownSize: + IntoIterator> + TryFrom>> + Into>>; + type ArraySimValue: AsRef<[SimValue]> + + AsMut<[SimValue]> + + BorrowMut<[SimValue]> + + 'static + + Clone + + std::fmt::Debug + + IntoIterator> + + TryFrom>> + + Into>>; } macro_rules! known_widths { @@ -60,6 +70,7 @@ macro_rules! known_widths { }> { const SIZE: Self = Self; type ArrayMatch = [Expr; Self::VALUE]; + type ArraySimValue = [SimValue; Self::VALUE]; } }; ([2 $($rest:tt)*] $($bits:literal)+) => { @@ -72,6 +83,7 @@ macro_rules! known_widths { impl KnownSize for ConstUsize<{2 $(* $rest)*}> { const SIZE: Self = Self; type ArrayMatch = [Expr; Self::VALUE]; + type ArraySimValue = [SimValue; Self::VALUE]; } }; } @@ -100,6 +112,15 @@ pub trait Size: + IntoIterator> + TryFrom>> + Into>>; + type ArraySimValue: AsRef<[SimValue]> + + AsMut<[SimValue]> + + BorrowMut<[SimValue]> + + 'static + + Clone + + std::fmt::Debug + + IntoIterator> + + TryFrom>> + + Into>>; const KNOWN_VALUE: Option; type SizeType: SizeType + Copy @@ -125,6 +146,7 @@ impl SizeType for usize { impl Size for DynSize { type ArrayMatch = Box<[Expr]>; + type ArraySimValue = Box<[SimValue]>; const KNOWN_VALUE: Option = None; type SizeType = usize; @@ -147,6 +169,7 @@ impl SizeType for T { impl Size for T { type ArrayMatch = ::ArrayMatch; + type ArraySimValue = ::ArraySimValue; const KNOWN_VALUE: Option = Some(T::VALUE); @@ -287,6 +310,7 @@ 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 @@ -306,6 +330,20 @@ 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 StaticType for $name { @@ -331,7 +369,7 @@ macro_rules! impl_int { } } - #[derive(Clone, PartialEq, Eq, Hash)] + #[derive(Clone, Eq, Hash)] pub struct $value { bits: Arc, _phantom: PhantomData, @@ -351,9 +389,15 @@ macro_rules! impl_int { } } - impl PartialOrd for $value { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) + 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())) } } @@ -401,6 +445,9 @@ 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 { @@ -748,6 +795,7 @@ 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 @@ -765,6 +813,18 @@ 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 { diff --git a/crates/fayalite/src/lib.rs b/crates/fayalite/src/lib.rs index 512572d..0843589 100644 --- a/crates/fayalite/src/lib.rs +++ b/crates/fayalite/src/lib.rs @@ -8,6 +8,8 @@ extern crate self as fayalite; +#[doc(hidden)] +pub use bitvec as __bitvec; #[doc(hidden)] pub use std as __std; diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs index dd6cff6..27bb04e 100644 --- a/crates/fayalite/src/phantom_const.rs +++ b/crates/fayalite/src/phantom_const.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information +use bitvec::slice::BitSlice; use serde::{de::DeserializeOwned, Deserialize, Serialize}; use crate::{ @@ -10,6 +11,7 @@ use crate::{ }, int::Bool, intern::{Intern, Interned, InternedCompare, LazyInterned, Memoize}, + sim::value::{SimValue, SimValuePartialEq}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; @@ -246,6 +248,7 @@ impl PhantomConst { impl Type for PhantomConst { type BaseType = PhantomConst; type MaskType = (); + type SimValue = (); impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { @@ -266,6 +269,19 @@ impl Type for PhantomConst { fn source_location() -> SourceLocation { SourceLocation::builtin() } + + fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { + assert!(bits.is_empty()); + () + } + + 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()); + } } impl StaticType for PhantomConst @@ -311,3 +327,10 @@ 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 + } +} diff --git a/crates/fayalite/src/reset.rs b/crates/fayalite/src/reset.rs index 9328365..312a8ea 100644 --- a/crates/fayalite/src/reset.rs +++ b/crates/fayalite/src/reset.rs @@ -7,6 +7,7 @@ use crate::{ source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; +use bitvec::slice::BitSlice; mod sealed { pub trait ResetTypeSealed {} @@ -45,6 +46,7 @@ macro_rules! reset_type { impl Type for $name { type BaseType = $name; type MaskType = Bool; + type SimValue = bool; impl_match_variant_as_self!(); @@ -66,6 +68,21 @@ 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 b508756..9be4889 100644 --- a/crates/fayalite/src/sim.rs +++ b/crates/fayalite/src/sim.rs @@ -14,7 +14,7 @@ use crate::{ }, ExprEnum, Flow, ToLiteralBits, }, - int::{BoolOrIntType, IntType, SIntValue, UIntValue}, + int::{BoolOrIntType, UIntValue}, intern::{ Intern, Interned, InternedCompare, Memoize, PtrEqWithTypeId, SupportsPtrEqWithTypeId, }, @@ -38,6 +38,7 @@ use crate::{ TypeIndexRange, TypeLayout, TypeLen, TypeParts, }, time::{SimDuration, SimInstant}, + value::SimValue, }, ty::StaticType, util::{BitSliceWriteWithBase, DebugAsDisplay}, @@ -72,6 +73,7 @@ use std::{ mod interpreter; pub mod time; +pub mod value; pub mod vcd; #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)] @@ -5904,635 +5906,6 @@ 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), @@ -7024,19 +6397,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, + let Self { compiled_value, io } = self; + SimulationImpl::read_no_settle_helper( + state, io, - bits, - } = self; - SimulationImpl::read_no_settle_helper(state, io, compiled_value, bits) + compiled_value, + UIntValue::new(Arc::new(BitVec::repeat(false, Expr::ty(io).bit_width()))), + ) } } @@ -7390,7 +6763,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, &value.bits) { + if Self::value_changed(&mut self.state, key, SimValue::bits(value).bits()) { Some(self.instant) } else { retval @@ -7688,7 +7061,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, @@ -7783,15 +7156,13 @@ impl SimulationImpl { state: &mut interpreter::State, io: Expr, compiled_value: CompiledValue, - mut bits: BitVec, + mut bits: UIntValue, ) -> SimValue { - bits.clear(); - bits.resize(compiled_value.layout.ty.bit_width(), false); SimulationImpl::read_write_sim_value_helper( state, compiled_value, 0, - &mut bits, + bits.bits_mut(), |_signed, bit_range, bits, value| { ::copy_bits_from_bigint_wrapping(value, &mut bits[bit_range]); }, @@ -7802,10 +7173,7 @@ impl SimulationImpl { bits[bit_range].clone_from_bitslice(bitslice); }, ); - SimValue { - ty: Expr::ty(io), - bits, - } + SimValue::from_bits(Expr::ty(io), bits) } /// doesn't modify `bits` fn value_changed( @@ -7847,11 +7215,7 @@ 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, - bits: BitVec::new(), - }) + .map(|compiled_value| ReadFn { compiled_value, io }) .apply_no_settle(&mut self.state); let (MaybeNeedsSettle::NeedsSettle(compiled_value) | MaybeNeedsSettle::NoSettleNeeded(compiled_value)) = compiled_value; @@ -7868,12 +7232,12 @@ impl SimulationImpl { .get_module_mut(which_module) .write_helper(io, which_module); self.state_ready_to_run = true; - assert_eq!(Expr::ty(io), value.ty()); + assert_eq!(Expr::ty(io), SimValue::ty(value)); Self::read_write_sim_value_helper( &mut self.state, compiled_value, 0, - &mut value.bits(), + &mut value.bits().bits(), |signed, bit_range, bits, value| { if signed { *value = SInt::bits_to_bigint(&bits[bit_range]); @@ -8167,10 +7531,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), - &value.into_sim_value(Expr::ty(io)).into_canonical(), + &SimValue::into_canonical(value.into_sim_value(Expr::ty(io))), $which_module, ); } diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs new file mode 100644 index 0000000..3e45016 --- /dev/null +++ b/crates/fayalite/src/sim/value.rs @@ -0,0 +1,665 @@ +// 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, Type}, + util::{ + alternating_cell::{AlternatingCell, AlternatingCellMethods}, + ConstUsize, + }, +}; +use bitvec::{slice::BitSlice, vec::BitVec}; +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) {} +} + +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 { + #[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 arc_into_sim_value(self: Arc, ty: T) -> SimValue { + self.to_sim_value(ty) + } + #[track_caller] + fn arc_to_sim_value(self: &Arc, ty: T) -> SimValue { + self.to_sim_value(ty) + } +} + +impl ToSimValue for SimValue { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + assert_eq!(SimValue::ty(self), ty); + self.clone() + } + + #[track_caller] + fn into_sim_value(self, ty: T) -> SimValue { + assert_eq!(SimValue::ty(&self), 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 { + Arc::new(self).arc_into_sim_value(ty) + } + + #[track_caller] + fn arc_into_sim_value(self: Arc, ty: T) -> SimValue { + SimValue::from_bits(ty, UIntValue::new_dyn(self)) + } + + #[track_caller] + fn arc_to_sim_value(self: &Arc, ty: T) -> SimValue { + SimValue::from_bits(ty, UIntValue::new_dyn(self.clone())) + } +} + +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 { + self.into_bitvec().into_sim_value(ty) + } +} + +impl ToSimValue for BitSlice { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + self.to_bitvec().into_sim_value(ty) + } +} + +impl, T: Type> ToSimValue for &'_ This { + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl, T: Type> ToSimValue for &'_ mut This { + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl, T: Type> ToSimValue for Arc { + fn to_sim_value(&self, ty: T) -> SimValue { + This::arc_to_sim_value(self, ty) + } + fn into_sim_value(self, ty: T) -> SimValue { + This::arc_into_sim_value(self, ty) + } +} + +impl + Send + Sync + 'static, T: Type> ToSimValue + for crate::intern::Interned +{ + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } +} + +impl, T: Type> ToSimValue for Box { + fn to_sim_value(&self, ty: T) -> SimValue { + This::to_sim_value(self, ty) + } + fn into_sim_value(self, ty: T) -> SimValue { + This::into_sim_value(*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(element_ty)), + ); + assert_eq!(elements.len(), ty.len()); + SimValue::from_value(ty, elements.try_into().ok().expect("already checked len")) + } +} + +impl, T: Type> ToSimValue> for [Element] { + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl> ToSimValue for [Element] { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } +} + +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(ty, self) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl, T: Type, const N: usize> ToSimValue> for [Element; N] { + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl, const N: usize> ToSimValue + for [Element; N] +{ + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } +} + +impl, T: Type> ToSimValue> for Vec { + #[track_caller] + fn to_sim_value(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } + #[track_caller] + fn into_sim_value(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl> ToSimValue for Vec { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } +} + +impl ToSimValue for Expr { + #[track_caller] + fn to_sim_value(&self, ty: T) -> SimValue { + assert_eq!(Expr::ty(*self), ty); + SimValue::from_bitslice( + ty, + &crate::expr::ToLiteralBits::to_literal_bits(self) + .expect("must be a literal expression"), + ) + } +} + +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::from_value(ty, *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 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::from_bits(ty, UIntValue::new(Arc::new(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::from_value(ty, (*self).into()) + } + } + + 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::from_value( + ty, + <<$prim as ToExpr>::Type as Type>::SimValue::from(*self).as_dyn_int(), + ) + } + } + + 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); + SimValue::into_canonical(self.to_sim_value(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<$IntType> for $IntValue { + fn to_sim_value(&self, ty: $IntType) -> SimValue<$IntType> { + self.bits().to_sim_value(ty) + } + + fn into_sim_value(self, ty: $IntType) -> SimValue<$IntType> { + self.into_bits().into_sim_value(ty) + } + } + + impl ToSimValue<$Int> for $IntValue { + fn to_sim_value(&self, ty: $Int) -> SimValue<$Int> { + self.bits().to_sim_value(ty) + } + + fn into_sim_value(self, ty: $Int) -> SimValue<$Int> { + self.into_bits().into_sim_value(ty) + } + } + + impl ToSimValue for $IntValue { + #[track_caller] + fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(self.to_sim_value($Int::from_canonical(ty))) + } + + #[track_caller] + fn into_sim_value(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(self.into_sim_value($Int::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 2786782..cd26c9b 100644 --- a/crates/fayalite/src/ty.rs +++ b/crates/fayalite/src/ty.rs @@ -7,14 +7,15 @@ use crate::{ clock::Clock, enum_::Enum, expr::Expr, - int::{Bool, SInt, UInt}, + int::{Bool, SInt, UInt, UIntValue}, intern::{Intern, Interned}, phantom_const::PhantomConst, reset::{AsyncReset, Reset, SyncReset}, source_location::SourceLocation, util::ConstUsize, }; -use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index}; +use bitvec::slice::BitSlice; +use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index, sync::Arc}; #[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)] #[non_exhaustive] @@ -268,6 +269,7 @@ pub trait Type: { type BaseType: BaseType; type MaskType: Type; + type SimValue: fmt::Debug + Clone + 'static; type MatchVariant: 'static + Send + Sync; type MatchActiveScope; type MatchVariantAndInactiveScope: MatchVariantAndInactiveScope< @@ -285,6 +287,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 + sealed::BaseTypeSealed + Into {} @@ -314,6 +319,7 @@ 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 { @@ -339,6 +345,48 @@ 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)] +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())), + } + } } pub trait StaticType: Type { diff --git a/crates/fayalite/src/util.rs b/crates/fayalite/src/util.rs index 66fc921..804ff19 100644 --- a/crates/fayalite/src/util.rs +++ b/crates/fayalite/src/util.rs @@ -1,6 +1,7 @@ // 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 new file mode 100644 index 0000000..17e06a6 --- /dev/null +++ b/crates/fayalite/src/util/alternating_cell.rs @@ -0,0 +1,122 @@ +// 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/tests/sim.rs b/crates/fayalite/tests/sim.rs index 450be54..eb5c79e 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -3,10 +3,16 @@ use fayalite::{ int::UIntValue, + memory::{ReadStruct, ReadWriteStruct, WriteStruct}, module::{instance_with_loc, reg_builder_with_loc}, prelude::*, reset::ResetType, - sim::{time::SimDuration, vcd::VcdWriterDecls, Simulation, ToSimValue}, + sim::{ + time::SimDuration, + value::{SimValue, ToSimValue}, + vcd::VcdWriterDecls, + Simulation, + }, ty::StaticType, util::RcWriter, }; @@ -396,32 +402,14 @@ fn test_enums() { sim.write_reset(sim.io().cd.rst, false); sim.advance_time(SimDuration::from_nanos(900)); type BOutTy = HdlOption<(UInt<1>, Bool)>; - #[derive(Debug)] + #[derive(Debug, PartialEq)] 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) - } + b_out: SimValue, } let io_cycles = [ IO { @@ -430,7 +418,7 @@ fn test_enums() { data_in: 0, which_out: 0, data_out: 0, - b_out: HdlNone(), + b_out: HdlNone().to_sim_value(StaticType::TYPE), }, IO { en: true, @@ -438,7 +426,7 @@ fn test_enums() { data_in: 0, which_out: 0, data_out: 0, - b_out: HdlNone(), + b_out: HdlNone().to_sim_value(StaticType::TYPE), }, IO { en: false, @@ -446,7 +434,7 @@ fn test_enums() { data_in: 0, which_out: 1, data_out: 0, - b_out: HdlSome((0_hdl_u1, false)), + b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), }, IO { en: true, @@ -454,7 +442,7 @@ fn test_enums() { data_in: 0xF, which_out: 1, data_out: 0, - b_out: HdlSome((0_hdl_u1, false)), + b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), }, IO { en: true, @@ -462,7 +450,7 @@ fn test_enums() { data_in: 0xF, which_out: 1, data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)), + b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), }, IO { en: true, @@ -470,7 +458,7 @@ fn test_enums() { data_in: 0xF, which_out: 1, data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)), + b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), }, IO { en: true, @@ -478,7 +466,7 @@ fn test_enums() { data_in: 0xF, which_out: 2, data_out: 0xF, - b_out: HdlNone(), + b_out: HdlNone().to_sim_value(StaticType::TYPE), }, ]; for ( @@ -510,7 +498,7 @@ fn test_enums() { .to_bigint() .try_into() .expect("known to be in range"), - b_out: sim.read(sim.io().b_out).to_expr(), + b_out: sim.read(sim.io().b_out), }; assert_eq!( expected, @@ -539,9 +527,9 @@ fn test_enums() { #[hdl_module(outline_generated)] pub fn memories() { #[hdl] - let r: fayalite::memory::ReadStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); + let r: ReadStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); #[hdl] - let w: fayalite::memory::WriteStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); + let w: WriteStruct<(UInt<8>, SInt<8>), ConstUsize<4>> = m.input(); #[hdl] let mut mem = memory_with_init([(0x01u8, 0x23i8); 16]); mem.read_latency(0); @@ -560,120 +548,131 @@ 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); - #[derive(Debug, PartialEq, Eq)] + #[hdl(cmp_eq)] struct IO { - r_addr: u8, - r_en: bool, - r_data: (u8, i8), - w_addr: u8, - w_en: bool, - w_data: (u8, i8), - w_mask: (bool, bool), + 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), } let io_cycles = [ + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: false, - r_data: (0, 0), - w_addr: 0, + r_data: (0u8, 0i8), + w_addr: 0_hdl_u4, w_en: false, - w_data: (0, 0), + w_data: (0u8, 0i8), w_mask: (false, false), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x1, 0x23), - w_addr: 0, + r_data: (0x1u8, 0x23i8), + w_addr: 0_hdl_u4, w_en: true, - w_data: (0x10, 0x20), + w_data: (0x10u8, 0x20i8), w_mask: (true, true), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x10, 0x20), - w_addr: 0, + r_data: (0x10u8, 0x20i8), + w_addr: 0_hdl_u4, w_en: true, - w_data: (0x30, 0x40), + w_data: (0x30u8, 0x40i8), w_mask: (false, true), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x10, 0x40), - w_addr: 0, + r_data: (0x10u8, 0x40i8), + w_addr: 0_hdl_u4, w_en: true, - w_data: (0x50, 0x60), + w_data: (0x50u8, 0x60i8), w_mask: (true, false), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x50, 0x40), - w_addr: 0, + r_data: (0x50u8, 0x40i8), + w_addr: 0_hdl_u4, w_en: true, - w_data: (0x70, -0x80), + w_data: (0x70u8, -0x80i8), w_mask: (false, false), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x50, 0x40), - w_addr: 0, + r_data: (0x50u8, 0x40i8), + w_addr: 0_hdl_u4, w_en: false, - w_data: (0x90, 0xA0u8 as i8), + w_data: (0x90u8, 0xA0u8 as i8), w_mask: (false, false), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x50, 0x40), - w_addr: 1, + r_data: (0x50u8, 0x40i8), + w_addr: 1_hdl_u4, w_en: true, - w_data: (0x90, 0xA0u8 as i8), + w_data: (0x90u8, 0xA0u8 as i8), w_mask: (true, true), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x50, 0x40), - w_addr: 2, + r_data: (0x50u8, 0x40i8), + w_addr: 2_hdl_u4, w_en: true, - w_data: (0xB0, 0xC0u8 as i8), + w_data: (0xB0u8, 0xC0u8 as i8), w_mask: (true, true), }, + #[hdl] IO { - r_addr: 0, + r_addr: 0_hdl_u4, r_en: true, - r_data: (0x50, 0x40), - w_addr: 2, + r_data: (0x50u8, 0x40i8), + w_addr: 2_hdl_u4, w_en: false, - w_data: (0xD0, 0xE0u8 as i8), + w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, + #[hdl] IO { - r_addr: 1, + r_addr: 1_hdl_u4, r_en: true, - r_data: (0x90, 0xA0u8 as i8), - w_addr: 2, + r_data: (0x90u8, 0xA0u8 as i8), + w_addr: 2_hdl_u4, w_en: false, - w_data: (0xD0, 0xE0u8 as i8), + w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, + #[hdl] IO { - r_addr: 2, + r_addr: 2_hdl_u4, r_en: true, - r_data: (0xB0, 0xC0u8 as i8), - w_addr: 2, + r_data: (0xB0u8, 0xC0u8 as i8), + w_addr: 2_hdl_u4, w_en: false, - w_data: (0xD0, 0xE0u8 as i8), + w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, ]; - for ( - cycle, - expected @ IO { + for (cycle, expected) in io_cycles.into_iter().enumerate() { + #[hdl] + let IO { r_addr, r_en, r_data: _, @@ -681,37 +680,26 @@ fn test_memories() { w_en, w_data, w_mask, - }, - ) 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 { + } = 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] + IO { r_addr, r_en, - 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"), - ), + r_data: sim.read(sim.io().r.data), w_addr, w_en, w_data, w_mask, - }; + }) + .to_sim_value(StaticType::TYPE); assert_eq!( - expected, + expected.to_sim_value(StaticType::TYPE), io, "vcd:\n{}\ncycle: {cycle}", String::from_utf8(writer.take()).unwrap(), @@ -739,7 +727,7 @@ fn test_memories() { #[hdl_module(outline_generated)] pub fn memories2() { #[hdl] - let rw: fayalite::memory::ReadWriteStruct, ConstUsize<3>> = m.input(); + let rw: ReadWriteStruct, ConstUsize<3>> = m.input(); #[hdl] let mut mem = memory_with_init([HdlSome(true); 5]); mem.read_latency(1); @@ -1012,9 +1000,9 @@ fn test_memories2() { #[hdl_module(outline_generated)] pub fn memories3() { #[hdl] - let r: fayalite::memory::ReadStruct, 8>, ConstUsize<3>> = m.input(); + let r: ReadStruct, 8>, ConstUsize<3>> = m.input(); #[hdl] - let w: fayalite::memory::WriteStruct, 8>, ConstUsize<3>> = m.input(); + let w: WriteStruct, 8>, ConstUsize<3>> = m.input(); #[hdl] let mut mem: MemBuilder, 8>> = memory(); mem.depth(8); diff --git a/crates/fayalite/tests/sim/expected/extern_module2.txt b/crates/fayalite/tests/sim/expected/extern_module2.txt index 96710fb..ec842ff 100644 --- a/crates/fayalite/tests/sim/expected/extern_module2.txt +++ b/crates/fayalite/tests/sim/expected/extern_module2.txt @@ -222,7 +222,9 @@ Simulation { }, value: SimValue { ty: Clock, - bits: 0x1, + value: OpaqueSimValue { + bits: 0x1_u1, + }, }, }, }, diff --git a/crates/fayalite/tests/sim/expected/ripple_counter.txt b/crates/fayalite/tests/sim/expected/ripple_counter.txt index e290ace..5472950 100644 --- a/crates/fayalite/tests/sim/expected/ripple_counter.txt +++ b/crates/fayalite/tests/sim/expected/ripple_counter.txt @@ -826,7 +826,9 @@ Simulation { }, value: SimValue { ty: Clock, - bits: 0x0, + value: OpaqueSimValue { + bits: 0x0_u1, + }, }, }, }, @@ -921,7 +923,9 @@ Simulation { }, value: SimValue { ty: Clock, - bits: 0x0, + value: OpaqueSimValue { + bits: 0x0_u1, + }, }, }, }, @@ -1016,7 +1020,9 @@ Simulation { }, value: SimValue { ty: Clock, - bits: 0x0, + value: OpaqueSimValue { + bits: 0x0_u1, + }, }, }, }, -- 2.43.6 From a40eaaa2da1731eb7af535dbd6b910408f3874dc Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Sun, 30 Mar 2025 00:55:38 -0700 Subject: [PATCH 4/7] expand SimValue support --- .../src/hdl_bundle.rs | 96 ++++ .../fayalite-proc-macros-impl/src/hdl_enum.rs | 46 ++ crates/fayalite-proc-macros-impl/src/lib.rs | 1 + .../src/module/transform_body.rs | 46 +- .../expand_aggregate_literals.rs | 111 ++++- .../src/module/transform_body/expand_match.rs | 113 +++-- crates/fayalite/src/bundle.rs | 85 ++-- crates/fayalite/src/int.rs | 9 +- crates/fayalite/src/phantom_const.rs | 32 +- crates/fayalite/src/sim.rs | 4 +- crates/fayalite/src/sim/value.rs | 455 +++++++++++++----- crates/fayalite/src/ty.rs | 12 +- crates/fayalite/tests/sim.rs | 196 ++++---- 13 files changed, 864 insertions(+), 342 deletions(-) diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs index a083def..8e49ac4 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs @@ -692,6 +692,12 @@ impl ToTokens for ParsedBundle { 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] @@ -797,6 +803,51 @@ 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 { @@ -900,6 +951,51 @@ 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 { diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index 0cdf85c..dd09a73 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -866,6 +866,24 @@ 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) + } + } } .to_tokens(tokens); if let (None, MaybeParsed::Parsed(generics)) = (no_static, &self.generics) { @@ -921,6 +939,34 @@ 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 5fe3ae8..4f7c4f0 100644 --- a/crates/fayalite-proc-macros-impl/src/lib.rs +++ b/crates/fayalite-proc-macros-impl/src/lib.rs @@ -93,6 +93,7 @@ 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/transform_body.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs index c67f8dc..8f427a9 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::{Nothing, Parse, ParseStream}, + parse::{Parse, ParseStream}, parse_quote, parse_quote_spanned, spanned::Spanned, token::Paren, @@ -27,6 +27,13 @@ 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), @@ -952,7 +959,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, @@ -1173,7 +1180,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, @@ -1181,10 +1188,10 @@ impl Visitor<'_> { then_branch, else_branch, } = expr_if; - 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, + 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, }); if let Expr::Let(ExprLet { attrs: let_attrs, @@ -1206,7 +1213,19 @@ impl Visitor<'_> { }, ); } - if let Some(else_expr) = else_expr { + 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 { parse_quote_spanned! {if_token.span=> #(#attrs)* { @@ -1675,7 +1694,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(), @@ -1694,10 +1713,11 @@ 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 b5a0ad3..8892bd5 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,45 +1,97 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use crate::{kw, module::transform_body::Visitor, HdlAttr}; +use crate::{ + kw, + module::transform_body::{ExprOptions, Visitor}, + HdlAttr, +}; use quote::{format_ident, quote_spanned}; use syn::{ - parse::Nothing, parse_quote, parse_quote_spanned, spanned::Spanned, Expr, ExprArray, ExprPath, - ExprRepeat, ExprStruct, ExprTuple, FieldValue, TypePath, + 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 { - 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)) - }; + 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) + } } - 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; - *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)} + 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) + } + } } pub(crate) fn process_hdl_struct( &mut self, - hdl_attr: HdlAttr, - expr_struct: ExprStruct, + hdl_attr: HdlAttr, + mut 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 @@ -91,12 +143,23 @@ impl Visitor<'_> { } pub(crate) fn process_hdl_tuple( &mut self, - hdl_attr: HdlAttr, - expr_tuple: ExprTuple, + hdl_attr: HdlAttr, + mut expr_tuple: ExprTuple, ) -> Expr { - self.require_normal_module_or_fn(hdl_attr); - parse_quote_spanned! {expr_tuple.span()=> - ::fayalite::expr::ToExpr::to_expr(&#expr_tuple) + 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) + } } } } 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 f1ff2c2..57e919a 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,7 +3,9 @@ use crate::{ fold::{impl_fold, DoFold}, kw, - module::transform_body::{empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, Visitor}, + module::transform_body::{ + empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, ExprOptions, Visitor, + }, Errors, HdlAttr, PairsIterExt, }; use proc_macro2::{Span, TokenStream}; @@ -11,7 +13,6 @@ 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, @@ -981,7 +982,7 @@ 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(); @@ -996,7 +997,6 @@ impl Visitor<'_> { init, semi_token, } = let_stmt; - self.require_normal_module_or_fn(let_token); let Some(syn::LocalInit { eq_token, expr, @@ -1031,29 +1031,48 @@ impl Visitor<'_> { errors: _, bindings, } = state; - 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"); + let ExprOptions { sim } = hdl_attr.body; + 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 ::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, + } + } 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_token #pat #eq_token __match_variant #semi_token - (#(#bindings,)* __scope,) - }; + 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,) + }; + } }; match retval { syn::Stmt::Local(retval) => retval, @@ -1062,7 +1081,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(); @@ -1074,7 +1093,6 @@ impl Visitor<'_> { brace_token: _, arms, } = expr_match; - self.require_normal_module_or_fn(match_token); let mut state = HdlMatchParseState { match_span: span, errors: &mut self.errors, @@ -1083,24 +1101,37 @@ impl Visitor<'_> { arms.into_iter() .filter_map(|arm| MatchArm::parse(&mut state, arm).ok()), ); - 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 { + let ExprOptions { sim } = hdl_attr.body; + 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 *__match_expr { #(#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/bundle.rs b/crates/fayalite/src/bundle.rs index 06e0411..9279b57 100644 --- a/crates/fayalite/src/bundle.rs +++ b/crates/fayalite/src/bundle.rs @@ -8,7 +8,7 @@ use crate::{ }, int::{Bool, DynSize}, intern::{Intern, Interned}, - sim::value::{SimValue, SimValuePartialEq, ToSimValue}, + sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{ impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, @@ -562,29 +562,29 @@ macro_rules! impl_tuples { BundleLiteral::new(ty, field_values[..].intern()).to_expr() } } - impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { + impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValue::::to_sim_value(self, Bundle::from_canonical(ty))) + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(ToSimValueWithType::::to_sim_value_with_type(self, Bundle::from_canonical(ty))) } #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValue::::into_sim_value(self, Bundle::from_canonical(ty))) + SimValue::into_canonical(ToSimValueWithType::::into_sim_value_with_type(self, Bundle::from_canonical(ty))) } } - impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { + impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: Bundle) -> SimValue { + fn to_sim_value_with_type(&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($ty_var.ty);)* - ToSimValue::into_sim_value(($($var,)*), ty) + $(let $var = $var.to_sim_value_with_type($ty_var.ty);)* + ToSimValueWithType::into_sim_value_with_type(($($var,)*), ty) } #[track_caller] - fn into_sim_value(self, ty: Bundle) -> SimValue { + fn into_sim_value_with_type(self, ty: Bundle) -> SimValue { #![allow(unused_mut)] #![allow(clippy::unused_unit)] let ($($var,)*) = self; @@ -592,29 +592,44 @@ macro_rules! impl_tuples { panic!("bundle has wrong number of fields"); }; let mut bits = BitVec::new(); - $(let $var = $var.into_sim_value($ty_var.ty); + $(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()); )* - bits.into_sim_value(ty) + bits.into_sim_value_with_type(ty) } } - impl<$($T: ToSimValue<$Ty>, $Ty: Type,)*> ToSimValue<($($Ty,)*)> for ($($T,)*) { + impl<$($T: ToSimValueWithType<$Ty>, $Ty: Type,)*> ToSimValueWithType<($($Ty,)*)> for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn to_sim_value_with_type(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.to_sim_value($ty_var);)* + $(let $var = $var.to_sim_value_with_type($ty_var);)* SimValue::from_value(ty, ($($var,)*)) } #[track_caller] - fn into_sim_value(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn into_sim_value_with_type(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.into_sim_value($ty_var);)* + $(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,)*)) + } + #[track_caller] + fn into_sim_value(self) -> SimValue { + let ($($var,)*) = self; + $(let $var = $var.to_sim_value();)* + SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*)) + } + } impl<$($Lhs: Type + ExprPartialEq<$Rhs>, $Rhs: Type,)*> ExprPartialEq<($($Rhs,)*)> for ($($Lhs,)*) { fn cmp_eq(lhs: Expr, rhs: Expr<($($Rhs,)*)>) -> Expr { let ($($lhs_var,)*) = *lhs; @@ -674,7 +689,7 @@ impl_tuples! { impl Type for PhantomData { type BaseType = Bundle; type MaskType = (); - type SimValue = (); + type SimValue = PhantomData; type MatchVariant = PhantomData; type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope; @@ -709,7 +724,7 @@ impl Type for PhantomData { } 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()); @@ -764,26 +779,38 @@ impl ToExpr for PhantomData { } } -impl ToSimValue for PhantomData { +impl ToSimValue for PhantomData { + type Type = PhantomData; + #[track_caller] - fn to_sim_value(&self, ty: Self) -> SimValue { - ToSimValue::into_sim_value(BitVec::new(), ty) + fn to_sim_value(&self) -> SimValue { + SimValue::from_value(*self, *self) } } -impl ToSimValue for PhantomData { +impl ToSimValueWithType for PhantomData { #[track_caller] - fn to_sim_value(&self, ty: Bundle) -> SimValue { + 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 { assert!(ty.fields().is_empty()); - ToSimValue::into_sim_value(BitVec::new(), ty) + ToSimValueWithType::into_sim_value_with_type(BitVec::new(), ty) } } -impl ToSimValue for PhantomData { +impl ToSimValueWithType for PhantomData { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { let ty = Bundle::from_canonical(ty); assert!(ty.fields().is_empty()); - SimValue::into_canonical(ToSimValue::into_sim_value(BitVec::new(), ty)) + SimValue::into_canonical(ToSimValueWithType::into_sim_value_with_type( + BitVec::new(), + ty, + )) } } diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs index a956dd5..373e150 100644 --- a/crates/fayalite/src/int.rs +++ b/crates/fayalite/src/int.rs @@ -2,12 +2,13 @@ // 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, + sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize}, @@ -58,7 +59,8 @@ pub trait KnownSize: + std::fmt::Debug + IntoIterator> + TryFrom>> - + Into>>; + + Into>> + + ToSimValueWithType>; } macro_rules! known_widths { @@ -120,7 +122,8 @@ pub trait Size: + std::fmt::Debug + IntoIterator> + TryFrom>> - + Into>>; + + Into>> + + ToSimValueWithType>; const KNOWN_VALUE: Option; type SizeType: SizeType + Copy diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs index 27bb04e..8422ae0 100644 --- a/crates/fayalite/src/phantom_const.rs +++ b/crates/fayalite/src/phantom_const.rs @@ -11,7 +11,7 @@ use crate::{ }, int::Bool, intern::{Intern, Interned, InternedCompare, LazyInterned, Memoize}, - sim::value::{SimValue, SimValuePartialEq}, + sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; @@ -248,7 +248,7 @@ impl PhantomConst { impl Type for PhantomConst { type BaseType = PhantomConst; type MaskType = (); - type SimValue = (); + type SimValue = PhantomConst; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { @@ -272,15 +272,17 @@ impl Type for PhantomConst { 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) { + 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) { + fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { assert!(bits.is_empty()); + assert_eq!(*value, *self); } } @@ -334,3 +336,23 @@ impl SimValuePartialEq for PhantomConst 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/sim.rs b/crates/fayalite/src/sim.rs index 9be4889..563cd37 100644 --- a/crates/fayalite/src/sim.rs +++ b/crates/fayalite/src/sim.rs @@ -7531,10 +7531,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(Expr::ty(io))), + &SimValue::into_canonical(value.into_sim_value_with_type(Expr::ty(io))), $which_module, ); } diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs index 3e45016..d415af4 100644 --- a/crates/fayalite/src/sim/value.rs +++ b/crates/fayalite/src/sim/value.rs @@ -9,7 +9,7 @@ use crate::{ expr::{CastBitsTo, Expr, ToExpr}, int::{Bool, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue}, reset::{AsyncReset, Reset, SyncReset}, - ty::{CanonicalType, Type}, + ty::{CanonicalType, StaticType, Type}, util::{ alternating_cell::{AlternatingCell, AlternatingCellMethods}, ConstUsize, @@ -307,122 +307,223 @@ impl SimValuePartialEq for Bool { } } -pub trait ToSimValue { +pub trait ToSimValue: ToSimValueWithType<::Type> { + type Type: Type; + #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue; + fn to_sim_value(&self) -> SimValue; #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue + fn into_sim_value(self) -> SimValue where Self: Sized, { - self.to_sim_value(ty) + self.to_sim_value() } #[track_caller] - fn arc_into_sim_value(self: Arc, ty: T) -> SimValue { - self.to_sim_value(ty) + fn arc_into_sim_value(self: Arc) -> SimValue { + self.to_sim_value() } #[track_caller] - fn arc_to_sim_value(self: &Arc, ty: T) -> SimValue { - self.to_sim_value(ty) + fn arc_to_sim_value(self: &Arc) -> SimValue { + self.to_sim_value() } } -impl ToSimValue for SimValue { +pub trait ToSimValueWithType { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - assert_eq!(SimValue::ty(self), ty); + 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() } - #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - assert_eq!(SimValue::ty(&self), ty); + fn into_sim_value(self) -> SimValue { self } } -impl ToSimValue for BitVec { +forward_to_sim_value_with_type!([T: Type] SimValue); + +impl ToSimValueWithType for BitVec { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.clone().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.clone().into_sim_value_with_type(ty) } #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - Arc::new(self).arc_into_sim_value(ty) + 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(self: Arc, ty: T) -> SimValue { + 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(self: &Arc, ty: T) -> SimValue { + fn arc_to_sim_value_with_type(self: &Arc, ty: T) -> SimValue { SimValue::from_bits(ty, UIntValue::new_dyn(self.clone())) } } -impl ToSimValue for bitvec::boxed::BitBox { +impl ToSimValueWithType for bitvec::boxed::BitBox { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.clone().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.clone().into_sim_value_with_type(ty) } #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - self.into_bitvec().into_sim_value(ty) + fn into_sim_value_with_type(self, ty: T) -> SimValue { + self.into_bitvec().into_sim_value_with_type(ty) } } -impl ToSimValue for BitSlice { +impl ToSimValueWithType for BitSlice { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.to_bitvec().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.to_bitvec().into_sim_value_with_type(ty) } } -impl, T: Type> ToSimValue for &'_ This { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +impl ToSimValue for &'_ This { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl, T: Type> ToSimValue for &'_ mut This { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +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, T: Type> ToSimValue for Arc { - fn to_sim_value(&self, ty: T) -> SimValue { - This::arc_to_sim_value(self, ty) - } - fn into_sim_value(self, ty: T) -> SimValue { - This::arc_into_sim_value(self, ty) +impl ToSimValue for &'_ mut This { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl + Send + Sync + 'static, T: Type> ToSimValue +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 { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) + type Type = This::Type; + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl, T: Type> ToSimValue for Box { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +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) } - fn into_sim_value(self, ty: T) -> SimValue { - This::into_sim_value(*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>>( + pub fn from_array_elements>>( ty: ArrayType, elements: I, ) -> Self { @@ -430,23 +531,32 @@ impl SimValue> { let elements = Vec::from_iter( elements .into_iter() - .map(|element| element.into_sim_value(element_ty)), + .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> ToSimValue> for [Element] { +impl, T: Type> ToSimValueWithType> for [Element] { #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl> ToSimValue for [Element] { +impl> ToSimValue for [Element] { + type Type = Array; + #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + 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, @@ -454,71 +564,61 @@ impl> ToSimValue for [Element] } } -impl, T: Type, const N: usize> ToSimValue> for [Element; N] +impl, T: Type, const N: usize> ToSimValueWithType> + for [Element; N] where ConstUsize: KnownSize, { #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl, T: Type, const N: usize> ToSimValue> for [Element; N] { - #[track_caller] - fn to_sim_value(&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) } - #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) + + fn into_sim_value(self) -> SimValue { + SimValue::from_array_elements(StaticType::TYPE, self) } } -impl, const N: usize> ToSimValue +impl, T: Type, const N: usize> ToSimValueWithType> for [Element; N] { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } - #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl, T: Type> ToSimValue> for Vec { - #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl> ToSimValue for Vec { +impl, const N: usize> ToSimValueWithType + for [Element; N] +{ #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + 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(self, ty: CanonicalType) -> SimValue { + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { SimValue::into_canonical(SimValue::from_array_elements( ::from_canonical(ty), self, @@ -526,37 +626,131 @@ impl> ToSimValue for Vec ToSimValue for Expr { +impl, T: Type> ToSimValueWithType> for Vec { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - assert_eq!(Expr::ty(*self), ty); + 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( - ty, + 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 ToSimValue<$ty> for bool { - fn to_sim_value(&self, ty: $ty) -> SimValue<$ty> { + 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 ToSimValue for bool { +impl ToSimValueWithType for bool { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { match ty { CanonicalType::UInt(_) | CanonicalType::SInt(_) @@ -579,19 +773,22 @@ impl ToSimValue for bool { macro_rules! impl_to_sim_value_for_primitive_int { ($prim:ident) => { - impl ToSimValue<<$prim as ToExpr>::Type> for $prim { + impl ToSimValue for $prim { + type Type = <$prim as ToExpr>::Type; + #[track_caller] fn to_sim_value( &self, - ty: <$prim as ToExpr>::Type, - ) -> SimValue<<$prim as ToExpr>::Type> { - SimValue::from_value(ty, (*self).into()) + ) -> SimValue { + SimValue::from_value(StaticType::TYPE, (*self).into()) } } - impl ToSimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { + forward_to_sim_value_with_type!([] $prim); + + impl ToSimValueWithType<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { #[track_caller] - fn to_sim_value( + fn to_sim_value_with_type( &self, ty: <<$prim as ToExpr>::Type as IntType>::Dyn, ) -> SimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> { @@ -602,11 +799,11 @@ macro_rules! impl_to_sim_value_for_primitive_int { } } - impl ToSimValue for $prim { + impl ToSimValueWithType for $prim { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + 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(ty)) + SimValue::into_canonical(self.to_sim_value_with_type(ty)) } } }; @@ -627,35 +824,51 @@ 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_sim_value(ty) + 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, ty: $IntType) -> SimValue<$IntType> { - self.into_bits().into_sim_value(ty) + fn into_sim_value(self) -> SimValue { + SimValue::from_value(self.ty(), self) } } - impl ToSimValue<$Int> for $IntValue { - fn to_sim_value(&self, ty: $Int) -> SimValue<$Int> { - self.bits().to_sim_value(ty) + 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(self, ty: $Int) -> SimValue<$Int> { - self.into_bits().into_sim_value(ty) + fn into_sim_value_with_type(self, ty: $IntType) -> SimValue<$IntType> { + SimValue::from_value(ty, self) } } - impl ToSimValue for $IntValue { + 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(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(self.to_sim_value($Int::from_canonical(ty))) + 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(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(self.into_sim_value($Int::from_canonical(ty))) + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical( + self.into_sim_value_with_type($IntType::::from_canonical(ty)), + ) } } }; diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs index cd26c9b..23680f7 100644 --- a/crates/fayalite/src/ty.rs +++ b/crates/fayalite/src/ty.rs @@ -11,6 +11,7 @@ use crate::{ intern::{Intern, Interned}, phantom_const::PhantomConst, reset::{AsyncReset, Reset, SyncReset}, + sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, util::ConstUsize, }; @@ -269,7 +270,7 @@ pub trait Type: { type BaseType: BaseType; type MaskType: Type; - type SimValue: fmt::Debug + Clone + 'static; + type SimValue: fmt::Debug + Clone + 'static + ToSimValueWithType; type MatchVariant: 'static + Send + Sync; type MatchActiveScope; type MatchVariantAndInactiveScope: MatchVariantAndInactiveScope< @@ -389,6 +390,15 @@ impl OpaqueSimValue { } } +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 { const TYPE: Self; const MASK_TYPE: Self::MaskType; diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs index eb5c79e..398fe18 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -7,13 +7,7 @@ use fayalite::{ module::{instance_with_loc, reg_builder_with_loc}, prelude::*, reset::ResetType, - sim::{ - time::SimDuration, - value::{SimValue, ToSimValue}, - vcd::VcdWriterDecls, - Simulation, - }, - ty::StaticType, + sim::{time::SimDuration, vcd::VcdWriterDecls, Simulation}, util::RcWriter, }; use std::num::NonZeroUsize; @@ -391,113 +385,110 @@ fn test_enums() { let mut sim = Simulation::new(enums()); let mut writer = RcWriter::default(); sim.add_trace_writer(VcdWriterDecls::new(writer.clone())); - 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.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.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().cd.clk, true); + sim.write(sim.io().cd.clk, true); sim.advance_time(SimDuration::from_nanos(100)); - sim.write_reset(sim.io().cd.rst, false); + sim.write(sim.io().cd.rst, false); sim.advance_time(SimDuration::from_nanos(900)); - type BOutTy = HdlOption<(UInt<1>, Bool)>; - #[derive(Debug, PartialEq)] + #[hdl(cmp_eq)] struct IO { - en: bool, - which_in: u8, - data_in: u8, - which_out: u8, - data_out: u8, - b_out: SimValue, + en: Bool, + which_in: UInt<2>, + data_in: UInt<4>, + which_out: UInt<2>, + data_out: UInt<4>, + b_out: HdlOption<(UInt<1>, Bool)>, } let io_cycles = [ + #[hdl(sim)] IO { en: false, - which_in: 0, - data_in: 0, - which_out: 0, - data_out: 0, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 0_hdl_u2, + data_in: 0_hdl_u4, + which_out: 0_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlNone(), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0, - which_out: 0, - data_out: 0, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0_hdl_u4, + which_out: 0_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlNone(), }, + #[hdl(sim)] IO { en: false, - which_in: 0, - data_in: 0, - which_out: 1, - data_out: 0, - b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), + which_in: 0_hdl_u2, + data_in: 0_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlSome((0_hdl_u1, false)), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0xF, - which_out: 1, - data_out: 0, - b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlSome((0_hdl_u1, false)), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0xF, - which_out: 1, - data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0x3_hdl_u4, + b_out: HdlSome((1_hdl_u1, true)), }, + #[hdl(sim)] IO { en: true, - which_in: 2, - data_in: 0xF, - which_out: 1, - data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), + which_in: 2_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0x3_hdl_u4, + b_out: HdlSome((1_hdl_u1, true)), }, + #[hdl(sim)] IO { en: true, - which_in: 2, - data_in: 0xF, - which_out: 2, - data_out: 0xF, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 2_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 2_hdl_u2, + data_out: 0xF_hdl_u4, + b_out: HdlNone(), }, ]; - for ( - cycle, - expected @ IO { + for (cycle, expected) in io_cycles.into_iter().enumerate() { + #[hdl(sim)] + let IO { en, which_in, data_in, which_out: _, data_out: _, b_out: _, - }, - ) 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 { + } = 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 { en, which_in, data_in, - 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"), + which_out: sim.read(sim.io().which_out), + data_out: sim.read(sim.io().data_out), b_out: sim.read(sim.io().b_out), }; assert_eq!( @@ -559,7 +550,7 @@ fn test_memories() { w_mask: (Bool, Bool), } let io_cycles = [ - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: false, @@ -569,7 +560,7 @@ fn test_memories() { w_data: (0u8, 0i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -579,7 +570,7 @@ fn test_memories() { w_data: (0x10u8, 0x20i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -589,7 +580,7 @@ fn test_memories() { w_data: (0x30u8, 0x40i8), w_mask: (false, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -599,7 +590,7 @@ fn test_memories() { w_data: (0x50u8, 0x60i8), w_mask: (true, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -609,7 +600,7 @@ fn test_memories() { w_data: (0x70u8, -0x80i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -619,7 +610,7 @@ fn test_memories() { w_data: (0x90u8, 0xA0u8 as i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -629,7 +620,7 @@ fn test_memories() { w_data: (0x90u8, 0xA0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -639,7 +630,7 @@ fn test_memories() { w_data: (0xB0u8, 0xC0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -649,7 +640,7 @@ fn test_memories() { w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 1_hdl_u4, r_en: true, @@ -659,7 +650,7 @@ fn test_memories() { w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 2_hdl_u4, r_en: true, @@ -671,7 +662,7 @@ fn test_memories() { }, ]; for (cycle, expected) in io_cycles.into_iter().enumerate() { - #[hdl] + #[hdl(sim)] let IO { r_addr, r_en, @@ -681,13 +672,13 @@ fn test_memories() { 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.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 { r_addr, r_en, @@ -696,20 +687,19 @@ fn test_memories() { w_en, w_data, w_mask, - }) - .to_sim_value(StaticType::TYPE); + }; assert_eq!( - expected.to_sim_value(StaticType::TYPE), + expected, io, "vcd:\n{}\ncycle: {cycle}", String::from_utf8(writer.take()).unwrap(), ); sim.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().r.clk, true); - sim.write_clock(sim.io().w.clk, true); + sim.write(sim.io().r.clk, true); + sim.write(sim.io().w.clk, true); sim.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().r.clk, false); - sim.write_clock(sim.io().w.clk, false); + sim.write(sim.io().r.clk, false); + sim.write(sim.io().w.clk, false); } sim.flush_traces().unwrap(); let vcd = String::from_utf8(writer.take()).unwrap(); -- 2.43.6 From 9092e45447136e332a346c82d4e2bb6bb16dac0f Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Sun, 30 Mar 2025 01:25:07 -0700 Subject: [PATCH 5/7] fix #[hdl(sim)] match on enums --- .../src/module/transform_body/expand_match.rs | 46 +++++++++++++++++-- crates/fayalite/tests/sim.rs | 6 +++ 2 files changed, 47 insertions(+), 5 deletions(-) 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 57e919a..a2e0375 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 @@ -83,7 +83,14 @@ visit_trait! { } } fn visit_match_pat_enum_variant(state: _, v: &MatchPatEnumVariant) { - let MatchPatEnumVariant {match_span:_, variant_path: _, enum_path: _, variant_name: _, field } = v; + let MatchPatEnumVariant { + match_span:_, + sim:_, + variant_path: _, + enum_path: _, + variant_name: _, + field, + } = v; if let Some((_, v)) = field { state.visit_match_pat_simple(v); } @@ -293,6 +300,7 @@ 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, @@ -304,6 +312,7 @@ impl ToTokens for MatchPatEnumVariant { fn to_tokens(&self, tokens: &mut TokenStream) { let Self { match_span, + sim, variant_path: _, enum_path, variant_name, @@ -313,7 +322,28 @@ impl ToTokens for MatchPatEnumVariant { __MatchTy::<#enum_path>::#variant_name } .to_tokens(tokens); - if let Some((paren_token, field)) = field { + 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 { paren_token.surround(tokens, |tokens| field.to_tokens(tokens)); } } @@ -448,6 +478,7 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, + sim: state.sim, variant_path, enum_path, variant_name, @@ -494,6 +525,7 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, + sim: state.sim, variant_path, enum_path, variant_name, @@ -578,6 +610,7 @@ trait ParseMatchPat: Sized { state, MatchPatEnumVariant { match_span: state.match_span, + sim: state.sim, variant_path, enum_path, variant_name, @@ -940,6 +973,7 @@ impl Fold for RewriteAsCheckMatch { } struct HdlMatchParseState<'a> { + sim: Option<(kw::sim,)>, match_span: Span, errors: &'a mut Errors, } @@ -986,6 +1020,7 @@ impl Visitor<'_> { 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()); } @@ -1015,6 +1050,7 @@ impl Visitor<'_> { } let Ok(pat) = MatchPat::parse( &mut HdlMatchParseState { + sim, match_span: span, errors: &mut self.errors, }, @@ -1031,7 +1067,6 @@ impl Visitor<'_> { errors: _, bindings, } = state; - let ExprOptions { sim } = hdl_attr.body; let retval = if sim.is_some() { parse_quote_spanned! {span=> let (#(#bindings,)*) = { @@ -1093,7 +1128,9 @@ impl Visitor<'_> { brace_token: _, arms, } = expr_match; + let ExprOptions { sim } = hdl_attr.body; let mut state = HdlMatchParseState { + sim, match_span: span, errors: &mut self.errors, }; @@ -1101,13 +1138,12 @@ impl Visitor<'_> { arms.into_iter() .filter_map(|arm| MatchArm::parse(&mut state, arm).ok()), ); - let ExprOptions { sim } = hdl_attr.body; 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 *__match_expr { + #match_token ::fayalite::sim::value::SimValue::into_value(__match_expr) { #(#arms)* } } diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs index 398fe18..71e53ea 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -497,6 +497,12 @@ 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); -- 2.43.6 From c4b6a0fee6501cf0dde3fb06422af3a96eca5fe3 Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Tue, 1 Apr 2025 22:05:42 -0700 Subject: [PATCH 6/7] add support for #[hdl(sim)] enum_ty.Variant(value) and #[hdl(sim)] EnumTy::Variant(value) and non-sim variants too --- crates/fayalite-proc-macros-impl/src/fold.rs | 1 + .../fayalite-proc-macros-impl/src/hdl_enum.rs | 74 ++ .../src/module/transform_body.rs | 2 + .../expand_aggregate_literals.rs | 115 ++- .../src/module/transform_body/expand_match.rs | 10 +- crates/fayalite/src/enum_.rs | 25 + crates/fayalite/tests/sim.rs | 72 +- crates/fayalite/tests/sim/expected/enums.txt | 846 +++++++++++------- crates/fayalite/tests/sim/expected/enums.vcd | 42 +- 9 files changed, 817 insertions(+), 370 deletions(-) diff --git a/crates/fayalite-proc-macros-impl/src/fold.rs b/crates/fayalite-proc-macros-impl/src/fold.rs index 49cc8c1..22e7b82 100644 --- a/crates/fayalite-proc-macros-impl/src/fold.rs +++ b/crates/fayalite-proc-macros-impl/src/fold.rs @@ -220,6 +220,7 @@ 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_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index dd09a73..6fb2a56 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -130,6 +130,8 @@ pub(crate) struct ParsedEnum { 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 { @@ -192,6 +194,8 @@ impl ParsedEnum { 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, }) } @@ -210,6 +214,8 @@ impl ToTokens for ParsedEnum { variants, match_variant_ident, sim_value_ident, + sim_builder_ident, + sim_builder_ty_field_ident, } = self; let span = ident.span(); let ItemOptions { @@ -412,6 +418,33 @@ 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( @@ -538,6 +571,25 @@ 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=> @@ -556,6 +608,18 @@ 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); @@ -848,6 +912,7 @@ impl ToTokens for ParsedEnum { 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) { @@ -884,6 +949,15 @@ impl ToTokens for ParsedEnum { ::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) { 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 8f427a9..a0f8eb0 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs @@ -1687,6 +1687,8 @@ 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, } } } 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 8892bd5..61f6c75 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,14 +1,20 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information + use crate::{ kw, - module::transform_body::{ExprOptions, Visitor}, + module::transform_body::{ + expand_match::{parse_enum_path, EnumPath}, + ExprOptions, Visitor, + }, HdlAttr, }; use quote::{format_ident, quote_spanned}; +use std::mem; use syn::{ - parse_quote_spanned, spanned::Spanned, Expr, ExprArray, ExprPath, ExprRepeat, ExprStruct, - ExprTuple, FieldValue, TypePath, + parse_quote_spanned, punctuated::Punctuated, spanned::Spanned, token::Paren, Expr, ExprArray, + ExprCall, ExprGroup, ExprMethodCall, ExprParen, ExprPath, ExprRepeat, ExprStruct, ExprTuple, + FieldValue, Token, TypePath, }; impl Visitor<'_> { @@ -162,4 +168,107 @@ impl Visitor<'_> { } } } + 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 a2e0375..68218c1 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 @@ -380,13 +380,13 @@ impl ToTokens for MatchPatSimple { } } -struct EnumPath { - variant_path: Path, - enum_path: Path, - variant_name: Ident, +pub(crate) struct EnumPath { + pub(crate) variant_path: Path, + pub(crate) enum_path: Path, + pub(crate) variant_name: Ident, } -fn parse_enum_path(variant_path: TypePath) -> Result { +pub(crate) fn parse_enum_path(variant_path: TypePath) -> Result { let TypePath { qself: None, path: variant_path, diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs index 9fa38e9..e37b7a5 100644 --- a/crates/fayalite/src/enum_.rs +++ b/crates/fayalite/src/enum_.rs @@ -259,6 +259,7 @@ pub trait EnumType: MatchVariantsIter = EnumMatchVariantsIter, > { + type SimBuilder: From; fn variants(&self) -> Interned<[EnumVariant]>; fn match_activate_scope( v: Self::MatchVariantAndInactiveScope, @@ -321,7 +322,18 @@ 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) { @@ -389,6 +401,9 @@ pub struct EnumPaddingSimValue { } impl EnumPaddingSimValue { + pub const fn new() -> Self { + Self { bits: None } + } pub fn bit_width(&self) -> Option { self.bits.as_ref().map(UIntValue::width) } @@ -659,6 +674,16 @@ impl<'a> EnumSimValueToBits<'a> { } } +#[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] pub enum HdlOption { HdlNone, diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs index 71e53ea..6433844 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -317,8 +317,13 @@ 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<1>, Bool)> = m.output(); + 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); #[hdl] struct MyStruct { @@ -358,7 +363,7 @@ pub fn enums() { } } - connect(b_out, HdlNone()); + connect(b_out, b_out_ty.HdlNone()); #[hdl] match the_reg { @@ -369,7 +374,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(b_out, HdlSome(v)); + connect_any(b_out, HdlSome(v)); } MyEnum::C(v) => { connect(which_out, 2_hdl_u2); @@ -396,100 +401,125 @@ fn test_enums() { sim.write(sim.io().cd.rst, false); sim.advance_time(SimDuration::from_nanos(900)); #[hdl(cmp_eq)] - struct IO { + struct IO { en: Bool, which_in: UInt<2>, data_in: UInt<4>, which_out: UInt<2>, data_out: UInt<4>, - b_out: HdlOption<(UInt<1>, Bool)>, + b_out: HdlOption<(UIntType, Bool)>, + b2_out: HdlOption<(UInt<1>, Bool)>, } + 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: HdlNone(), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlNone(), + b2_out: #[hdl(sim)] + 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: HdlNone(), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlNone(), + b2_out: #[hdl(sim)] + 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: HdlSome((0_hdl_u1, false)), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlSome((0u8.cast_to(UInt[1]), false)), + b2_out: #[hdl(sim)] + 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: HdlSome((0_hdl_u1, false)), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlSome((0u8.cast_to(UInt[1]), false)), + b2_out: #[hdl(sim)] + 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: HdlSome((1_hdl_u1, true)), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlSome((1u8.cast_to(UInt[1]), true)), + b2_out: #[hdl(sim)] + 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: HdlSome((1_hdl_u1, true)), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlSome((1u8.cast_to(UInt[1]), true)), + b2_out: #[hdl(sim)] + 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: HdlNone(), + b_out: #[hdl(sim)] + (io_ty.b_out).HdlNone(), + b2_out: #[hdl(sim)] + HdlNone(), }, ]; for (cycle, expected) in io_cycles.into_iter().enumerate() { #[hdl(sim)] - let IO { + let 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 { + 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), }; assert_eq!( expected, diff --git a/crates/fayalite/tests/sim/expected/enums.txt b/crates/fayalite/tests/sim/expected/enums.txt index 089ea31..61ce5d5 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: 6, + len: 7, debug_data: [ SlotDebugData { name: "", @@ -13,6 +13,13 @@ Simulation { HdlSome, }, }, + SlotDebugData { + name: "", + ty: Enum { + HdlNone, + HdlSome, + }, + }, SlotDebugData { name: "", ty: Bool, @@ -41,7 +48,7 @@ Simulation { .. }, big_slots: StatePartLayout { - len: 103, + len: 111, debug_data: [ SlotDebugData { name: "InstantiatedModule(enums: enums).enums::cd.clk", @@ -106,6 +113,41 @@ 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 { @@ -498,594 +540,640 @@ Simulation { insns: [ // at: module-XXXXXXXXXX.rs:1:1 0: Const { - dest: StatePartIndex(90), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(98), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, value: 0x1, }, 1: Const { - dest: StatePartIndex(82), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(90), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, value: 0x0, }, 2: Const { - dest: StatePartIndex(80), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(88), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, value: 0x0, }, 3: Copy { - 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> }, + 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> }, }, - // at: module-XXXXXXXXXX.rs:16:1 + // at: module-XXXXXXXXXX.rs:18: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(81), // (0x0) SlotDebugData { name: "", 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})} }, }, // at: module-XXXXXXXXXX.rs:1:1 5: SliceInt { - dest: StatePartIndex(69), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(77), // (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(70), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, - src: StatePartIndex(69), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(78), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + src: StatePartIndex(77), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, dest_width: 2, }, 7: Const { - dest: StatePartIndex(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(70), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, value: 0x2, }, 8: SliceInt { - dest: StatePartIndex(49), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(57), // (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(50), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(49), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(57), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 10: Copy { - dest: StatePartIndex(68), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(50), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(76), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 11: SliceInt { - dest: StatePartIndex(46), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(54), // (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(47), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(46), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(55), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(54), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 13: Copy { - dest: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(55), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 14: Copy { - dest: StatePartIndex(44), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(52), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + src: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 15: Copy { - dest: StatePartIndex(45), // (0x1) SlotDebugData { name: ".1", ty: Bool }, - src: StatePartIndex(50), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(53), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + src: StatePartIndex(58), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 16: Copy { - dest: StatePartIndex(66), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, - src: StatePartIndex(48), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(74), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + src: StatePartIndex(56), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 17: Copy { - dest: StatePartIndex(67), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, - src: StatePartIndex(68), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(75), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + src: StatePartIndex(76), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 18: Copy { - dest: StatePartIndex(63), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, - src: StatePartIndex(66), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + dest: StatePartIndex(71), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + src: StatePartIndex(74), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, }, 19: Copy { - dest: StatePartIndex(64), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, - src: StatePartIndex(67), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + dest: StatePartIndex(72), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + src: StatePartIndex(75), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, }, 20: Copy { - dest: StatePartIndex(65), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, - src: StatePartIndex(70), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + dest: StatePartIndex(73), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + src: StatePartIndex(78), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, }, 21: Copy { - dest: StatePartIndex(58), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, - src: StatePartIndex(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(66), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> }, + src: StatePartIndex(70), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, }, 22: Copy { - dest: StatePartIndex(59), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, - src: StatePartIndex(63), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + dest: StatePartIndex(67), // (0x1) SlotDebugData { name: ".1.a[0]", ty: UInt<1> }, + src: StatePartIndex(71), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, }, 23: Copy { - dest: StatePartIndex(60), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, - src: StatePartIndex(64), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + dest: StatePartIndex(68), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, + src: StatePartIndex(72), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, }, 24: Copy { - dest: StatePartIndex(61), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, - src: StatePartIndex(65), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + dest: StatePartIndex(69), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, + src: StatePartIndex(73), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, }, 25: Shl { - dest: StatePartIndex(71), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(60), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, + dest: StatePartIndex(79), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(68), // (0x1) SlotDebugData { name: ".1.a[1]", ty: UInt<1> }, rhs: 1, }, 26: Or { - 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> }, + 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> }, }, 27: CastToUInt { - dest: StatePartIndex(73), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(61), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, + dest: StatePartIndex(81), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(69), // (-0x1) SlotDebugData { name: ".1.b", ty: SInt<2> }, dest_width: 2, }, 28: Shl { - dest: StatePartIndex(74), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(73), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(82), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(81), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 29: Or { - 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> }, + 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> }, }, 30: Shl { - dest: StatePartIndex(76), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, - lhs: StatePartIndex(75), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(84), // (0x3c) SlotDebugData { name: "", ty: UInt<6> }, + lhs: StatePartIndex(83), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, rhs: 2, }, 31: Or { - 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> }, + 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> }, }, 32: CastToUInt { - dest: StatePartIndex(78), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, - src: StatePartIndex(77), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(86), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + src: StatePartIndex(85), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, dest_width: 6, }, 33: Copy { - 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> }, + 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> }, }, 34: Const { - dest: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, value: 0x1, }, 35: CmpEq { - dest: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(48), // (0x0) SlotDebugData { name: "", ty: Bool }, lhs: StatePartIndex(3), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_in", ty: UInt<2> }, - rhs: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, }, 36: Copy { - dest: StatePartIndex(41), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, - src: StatePartIndex(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(49), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> }, + src: StatePartIndex(47), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, }, 37: Copy { - dest: StatePartIndex(42), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, - src: StatePartIndex(44), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + dest: StatePartIndex(50), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, + src: StatePartIndex(52), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, }, 38: Copy { - dest: StatePartIndex(43), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, - src: StatePartIndex(45), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + dest: StatePartIndex(51), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + src: StatePartIndex(53), // (0x1) SlotDebugData { name: ".1", ty: Bool }, }, 39: Copy { - dest: StatePartIndex(51), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(43), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, + dest: StatePartIndex(59), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(51), // (0x1) SlotDebugData { name: ".1.1", ty: Bool }, }, 40: Shl { - dest: StatePartIndex(52), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(51), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(60), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(59), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, rhs: 1, }, 41: Or { - 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> }, + 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> }, }, 42: Shl { - dest: StatePartIndex(54), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(53), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(62), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(61), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 43: Or { - 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> }, + 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> }, }, 44: CastToUInt { - dest: StatePartIndex(56), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, - src: StatePartIndex(55), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(64), // (0xd) SlotDebugData { name: "", ty: UInt<6> }, + src: StatePartIndex(63), // (0xd) SlotDebugData { name: "", ty: UInt<4> }, dest_width: 6, }, 45: Copy { - 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> }, + 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> }, }, 46: Const { - dest: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, value: 0x0, }, 47: CmpEq { - dest: StatePartIndex(38), // (0x0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(46), // (0x0) SlotDebugData { name: "", ty: Bool }, lhs: StatePartIndex(3), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_in", ty: UInt<2> }, - rhs: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, + rhs: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, }, 48: Copy { - 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>})} }, + 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>})} }, }, 49: SliceInt { - dest: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(21), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(29), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, start: 2, len: 2, }, 50: SliceInt { - dest: StatePartIndex(23), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(31), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, 51: SliceInt { - dest: StatePartIndex(24), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(22), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(32), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(30), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, 52: Copy { - dest: StatePartIndex(25), // (0x1) SlotDebugData { name: "", ty: Bool }, - src: StatePartIndex(24), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: Bool }, + src: StatePartIndex(32), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 53: Copy { - dest: StatePartIndex(19), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, - src: StatePartIndex(23), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(27), // (0x1) SlotDebugData { name: ".0", ty: UInt<1> }, + src: StatePartIndex(31), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 54: Copy { - dest: StatePartIndex(20), // (0x1) SlotDebugData { name: ".1", ty: Bool }, - src: StatePartIndex(25), // (0x1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(28), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + src: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: Bool }, }, 55: Copy { - dest: StatePartIndex(83), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(20), // (0x1) SlotDebugData { name: ".1", ty: Bool }, + dest: StatePartIndex(91), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(28), // (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, }, - 64: Or { + 57: Or { dest: StatePartIndex(93), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(88), // (0x1) SlotDebugData { name: ".1.0", ty: UInt<1> }, + lhs: StatePartIndex(27), // (0x1) SlotDebugData { name: ".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(94), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, - lhs: StatePartIndex(93), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(102), // (0x6) SlotDebugData { name: "", ty: UInt<3> }, + lhs: StatePartIndex(101), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 1, }, 66: Or { - 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> }, + 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> }, }, 67: CastToUInt { - dest: StatePartIndex(96), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, - src: StatePartIndex(95), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + dest: StatePartIndex(104), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, + src: StatePartIndex(103), // (0x7) SlotDebugData { name: "", ty: UInt<3> }, dest_width: 3, }, 68: Copy { - 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> }, + 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> }, }, 69: SliceInt { - dest: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, - src: StatePartIndex(21), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(29), // (0x3e) SlotDebugData { name: "", ty: UInt<6> }, start: 2, len: 4, }, 70: SliceInt { - dest: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, start: 0, len: 2, }, 71: SliceInt { - dest: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, 72: SliceInt { - dest: StatePartIndex(34), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, - src: StatePartIndex(32), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(42), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + src: StatePartIndex(40), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, 73: Copy { - dest: StatePartIndex(29), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, - src: StatePartIndex(33), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(37), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + src: StatePartIndex(41), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 74: Copy { - dest: StatePartIndex(30), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, - src: StatePartIndex(34), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, + dest: StatePartIndex(38), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + src: StatePartIndex(42), // (0x1) SlotDebugData { name: "", ty: UInt<1> }, }, 75: SliceInt { - dest: StatePartIndex(35), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(31), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + dest: StatePartIndex(43), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(39), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, start: 2, len: 2, }, 76: CastToSInt { - dest: StatePartIndex(36), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, - src: StatePartIndex(35), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(44), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + src: StatePartIndex(43), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, dest_width: 2, }, 77: Copy { - dest: StatePartIndex(26), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, - src: StatePartIndex(29), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, + dest: StatePartIndex(34), // (0x1) SlotDebugData { name: ".a[0]", ty: UInt<1> }, + src: StatePartIndex(37), // (0x1) SlotDebugData { name: "[0]", ty: UInt<1> }, }, 78: Copy { - dest: StatePartIndex(27), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, - src: StatePartIndex(30), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, + dest: StatePartIndex(35), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + src: StatePartIndex(38), // (0x1) SlotDebugData { name: "[1]", ty: UInt<1> }, }, 79: Copy { - dest: StatePartIndex(28), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, - src: StatePartIndex(36), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, + dest: StatePartIndex(36), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + src: StatePartIndex(44), // (-0x1) SlotDebugData { name: "", ty: SInt<2> }, }, 80: Shl { - dest: StatePartIndex(98), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, - lhs: StatePartIndex(27), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, + dest: StatePartIndex(106), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + lhs: StatePartIndex(35), // (0x1) SlotDebugData { name: ".a[1]", ty: UInt<1> }, rhs: 1, }, 81: Or { - 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> }, + 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> }, }, 82: CastToUInt { - dest: StatePartIndex(100), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, - src: StatePartIndex(28), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, + dest: StatePartIndex(108), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(36), // (-0x1) SlotDebugData { name: ".b", ty: SInt<2> }, dest_width: 2, }, 83: Shl { - dest: StatePartIndex(101), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, - lhs: StatePartIndex(100), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, + dest: StatePartIndex(109), // (0xc) SlotDebugData { name: "", ty: UInt<4> }, + lhs: StatePartIndex(108), // (0x3) SlotDebugData { name: "", ty: UInt<2> }, rhs: 2, }, 84: Or { - 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> }, + 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> }, }, - // at: module-XXXXXXXXXX.rs:9:1 + // at: module-XXXXXXXXXX.rs:11:1 85: AndBigWithSmallImmediate { - 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>})} }, + 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>})} }, rhs: 0x3, }, - // at: module-XXXXXXXXXX.rs:17:1 + // at: module-XXXXXXXXXX.rs:19:1 86: BranchIfSmallNeImmediate { target: 89, - lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, rhs: 0x0, }, - // at: module-XXXXXXXXXX.rs:18:1 + // at: module-XXXXXXXXXX.rs:20:1 87: Copy { dest: StatePartIndex(5), // (0x2) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::which_out", ty: UInt<2> }, - src: StatePartIndex(37), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, - }, - // 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(82), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, - }, - // at: module-XXXXXXXXXX.rs:17:1 - 89: BranchIfSmallNeImmediate { - target: 93, - lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, - rhs: 0x1, - }, - // 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(39), // (0x1) SlotDebugData { name: "", ty: UInt<2> }, + src: StatePartIndex(45), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, }, // at: module-XXXXXXXXXX.rs:21:1 - 91: Copy { + 88: Copy { dest: StatePartIndex(6), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_out", ty: UInt<4> }, - src: StatePartIndex(86), // (0x3) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(90), // (0x0) SlotDebugData { name: "", ty: UInt<4> }, + }, + // at: module-XXXXXXXXXX.rs:19:1 + 89: BranchIfSmallNeImmediate { + target: 93, + lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + rhs: 0x1, }, // 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(97), // (0x7) SlotDebugData { name: "", ty: Enum {HdlNone, HdlSome(Bundle {0: UInt<1>, 1: Bool})} }, - }, - // at: module-XXXXXXXXXX.rs:17:1 - 93: BranchIfSmallNeImmediate { - target: 96, - lhs: StatePartIndex(5), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, - rhs: 0x2, + 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> }, }, // 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(62), // (0x2) SlotDebugData { name: "", ty: UInt<2> }, + 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> }, }, // at: module-XXXXXXXXXX.rs:24: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})} }, + }, + // at: module-XXXXXXXXXX.rs:19:1 + 93: BranchIfSmallNeImmediate { + target: 96, + lhs: StatePartIndex(6), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} }, + rhs: 0x2, + }, + // at: module-XXXXXXXXXX.rs:25: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> }, + }, + // at: module-XXXXXXXXXX.rs:26:1 95: Copy { dest: StatePartIndex(6), // (0xf) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::data_out", ty: UInt<4> }, - src: StatePartIndex(102), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, + src: StatePartIndex(110), // (0xf) SlotDebugData { name: "", ty: UInt<4> }, }, - // at: module-XXXXXXXXXX.rs:9:1 + // at: module-XXXXXXXXXX.rs:11:1 96: IsNonZeroDestIsSmall { - dest: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(5), // (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(17), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, + dest: StatePartIndex(25), // (0x0) SlotDebugData { name: "", ty: UInt<6> }, value: 0x0, }, 98: Copy { - 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> }, + 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> }, }, - // at: module-XXXXXXXXXX.rs:10:1 + // at: module-XXXXXXXXXX.rs:12:1 99: BranchIfZero { target: 107, value: StatePartIndex(2), // (0x1) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::en", ty: Bool }, }, - // at: module-XXXXXXXXXX.rs:11:1 + // at: module-XXXXXXXXXX.rs:13:1 100: BranchIfZero { target: 102, - value: StatePartIndex(38), // (0x0) SlotDebugData { name: "", ty: Bool }, - }, - // at: module-XXXXXXXXXX.rs:12:1 - 101: 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(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 }, + value: StatePartIndex(46), // (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>})} }, + 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 - 105: BranchIfNonZero { + 102: BranchIfNonZero { target: 107, - value: StatePartIndex(40), // (0x0) SlotDebugData { name: "", ty: Bool }, + value: StatePartIndex(46), // (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>})} }, + 103: BranchIfZero { + target: 105, + value: StatePartIndex(48), // (0x0) SlotDebugData { name: "", ty: Bool }, }, - // at: module-XXXXXXXXXX.rs:9:1 + // 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>})} }, + }, + // at: module-XXXXXXXXXX.rs:11:1 107: IsNonZeroDestIsSmall { - dest: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, + dest: StatePartIndex(4), // (0x1 1) SlotDebugData { name: "", ty: Bool }, src: StatePartIndex(0), // (0x1) SlotDebugData { name: "InstantiatedModule(enums: enums).enums::cd.clk", ty: Clock }, }, 108: AndSmall { - 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 }, + 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 }, + }, + // at: module-XXXXXXXXXX.rs:10: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 - 109: Copy { + 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})} }, }, - 110: SliceInt { + 119: SliceInt { dest: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, src: StatePartIndex(10), // (0x0) SlotDebugData { name: "", ty: UInt<3> }, start: 1, len: 2, }, - 111: SliceInt { + 120: SliceInt { dest: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, start: 0, len: 1, }, - 112: SliceInt { + 121: SliceInt { dest: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, src: StatePartIndex(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> }, start: 1, len: 1, }, - 113: Copy { + 122: Copy { dest: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: Bool }, src: StatePartIndex(13), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, }, - 114: Copy { + 123: Copy { dest: StatePartIndex(8), // (0x0) SlotDebugData { name: ".0", ty: UInt<1> }, src: StatePartIndex(12), // (0x0) SlotDebugData { name: "", ty: UInt<1> }, }, - 115: Copy { + 124: Copy { dest: StatePartIndex(9), // (0x0) SlotDebugData { name: ".1", ty: Bool }, src: StatePartIndex(14), // (0x0) SlotDebugData { name: "", ty: Bool }, }, // at: module-XXXXXXXXXX.rs:8:1 - 116: AndBigWithSmallImmediate { + 125: 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:9:1 - 117: BranchIfSmallZero { - target: 122, - value: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + // at: module-XXXXXXXXXX.rs:11:1 + 126: BranchIfSmallZero { + target: 131, + value: StatePartIndex(3), // (0x0 0) SlotDebugData { name: "", ty: Bool }, }, - 118: BranchIfSmallNonZero { - target: 121, - value: StatePartIndex(4), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + 127: BranchIfSmallNonZero { + target: 130, + value: StatePartIndex(5), // (0x0 0) SlotDebugData { name: "", ty: Bool }, }, - 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>})} }, + 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>})} }, }, - 120: Branch { - target: 122, + 129: Branch { + target: 131, }, - 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>})} }, + 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>})} }, }, - 122: XorSmallImmediate { - dest: StatePartIndex(1), // (0x0 0) SlotDebugData { name: "", ty: Bool }, - lhs: StatePartIndex(3), // (0x1 1) SlotDebugData { name: "", ty: Bool }, + 131: XorSmallImmediate { + dest: StatePartIndex(2), // (0x0 0) SlotDebugData { name: "", ty: Bool }, + lhs: StatePartIndex(4), // (0x1 1) SlotDebugData { name: "", ty: Bool }, rhs: 0x1, }, // at: module-XXXXXXXXXX.rs:1:1 - 123: Return, + 132: Return, ], .. }, - pc: 123, + pc: 132, memory_write_log: [], memories: StatePart { value: [], @@ -1095,6 +1183,7 @@ Simulation { 0, 0, 0, + 0, 1, 0, 2, @@ -1117,6 +1206,14 @@ Simulation { 0, 0, 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, 62, 62, 0, @@ -1266,9 +1363,23 @@ 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 { @@ -1476,23 +1587,22 @@ Simulation { }, flow: Sink, }, - TraceReg { - name: "the_reg", + TraceModuleIO { + name: "b2_out", child: TraceEnumWithFields { - name: "the_reg", + name: "b2_out", discriminant: TraceEnumDiscriminant { location: TraceScalarId(10), name: "$tag", ty: Enum { - A, - B(Bundle {0: UInt<1>, 1: Bool}), - C(Bundle {a: Array, 2>, b: SInt<2>}), + HdlNone, + HdlSome(Bundle {0: UInt<1>, 1: Bool}), }, - flow: Duplex, + flow: Sink, }, non_empty_fields: [ TraceBundle { - name: "B", + name: "HdlSome", fields: [ TraceUInt { location: TraceScalarId(11), @@ -1514,6 +1624,57 @@ 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: [ @@ -1521,13 +1682,13 @@ Simulation { name: "a", elements: [ TraceUInt { - location: TraceScalarId(13), + location: TraceScalarId(16), name: "[0]", ty: UInt<1>, flow: Source, }, TraceUInt { - location: TraceScalarId(14), + location: TraceScalarId(17), name: "[1]", ty: UInt<1>, flow: Source, @@ -1537,7 +1698,7 @@ Simulation { flow: Source, }, TraceSInt { - location: TraceScalarId(15), + location: TraceScalarId(18), name: "b", ty: SInt<2>, flow: Source, @@ -1660,7 +1821,36 @@ Simulation { SimTrace { id: TraceScalarId(10), kind: EnumDiscriminant { - index: StatePartIndex(5), + 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), ty: Enum { A, B(Bundle {0: UInt<1>, 1: Bool}), @@ -1670,32 +1860,6 @@ 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 { @@ -1707,8 +1871,34 @@ Simulation { }, SimTrace { id: TraceScalarId(15), - kind: BigSInt { + 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), ty: SInt<2>, }, state: 0x3, @@ -1727,7 +1917,7 @@ Simulation { ], instant: 16 μs, clocks_triggered: [ - StatePartIndex(2), + StatePartIndex(3), ], .. } \ 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 07cbd32..aff867b 100644 --- a/crates/fayalite/tests/sim/expected/enums.vcd +++ b/crates/fayalite/tests/sim/expected/enums.vcd @@ -16,18 +16,25 @@ $var wire 1 ) \0 $end $var wire 1 * \1 $end $upscope $end $upscope $end -$scope struct the_reg $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 $scope struct B $end -$var reg 1 , \0 $end -$var reg 1 - \1 $end +$var reg 1 / \0 $end +$var reg 1 0 \1 $end $upscope $end $scope struct C $end $scope struct a $end -$var reg 1 . \[0] $end -$var reg 1 / \[1] $end +$var reg 1 1 \[0] $end +$var reg 1 2 \[1] $end $upscope $end -$var reg 2 0 b $end +$var reg 2 3 b $end $upscope $end $upscope $end $upscope $end @@ -43,12 +50,15 @@ b0 ' sHdlNone\x20(0) ( 0) 0* -sA\x20(0) + +sHdlNone\x20(0) + 0, 0- -0. +sA\x20(0) . 0/ -b0 0 +00 +01 +02 +b0 3 $end #1000000 1! @@ -66,7 +76,8 @@ b1 $ 1! b1 & sHdlSome\x20(1) ( -sB\x20(1) + +sHdlSome\x20(1) + +sB\x20(1) . #6000000 0# b0 $ @@ -85,8 +96,10 @@ b11 ' 1* 1, 1- -1. 1/ +10 +11 +12 #10000000 0! #11000000 @@ -101,8 +114,11 @@ b1111 ' sHdlNone\x20(0) ( 0) 0* -sC\x20(2) + -b11 0 +sHdlNone\x20(0) + +0, +0- +sC\x20(2) . +b11 3 #14000000 0! #15000000 -- 2.43.6 From 62058dc141b2673d502295730b29abf1351b3ca1 Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Tue, 1 Apr 2025 22:22:54 -0700 Subject: [PATCH 7/7] fix cargo doc warnings -- convert urls to auto links --- crates/fayalite/src/util/prefix_sum.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/fayalite/src/util/prefix_sum.rs b/crates/fayalite/src/util/prefix_sum.rs index 758d89c..98e6d95 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, } -- 2.43.6