[vastly] Add fixture runner and speed up pipeline simulation

xlsynth-vastly/Cargo.toml

@@ -18,8 +18,9 @@ path = "src/lib.rs"
 
 [dependencies]
 clap = { version = "4.5.21", features = ["derive"] }
-xlsynth = { path = "../xlsynth", version = "0.37.0" }
+xlsynth = { path = "../xlsynth", version = "0.37.0", optional = true }
 
 [features]
 default = []
+irvals = ["dep:xlsynth"]
 reference-sim-tests = []

xlsynth-vastly/src/bin/vastly-sim-pipeline.rs

@@ -7,13 +7,6 @@ use clap::ArgAction;
 use clap::Parser;
 
 use std::collections::BTreeSet;
-use xlsynth_vastly::CoverageCounters;
-use xlsynth_vastly::LogicBit;
-use xlsynth_vastly::PipelineCycle;
-use xlsynth_vastly::PipelineStimulus;
-use xlsynth_vastly::Signedness;
-use xlsynth_vastly::SourceText;
-use xlsynth_vastly::Value4;
 use xlsynth_vastly::compile_pipeline_module_with_defines;
 use xlsynth_vastly::compute_coverability_or_fallback_with_defines;
 use xlsynth_vastly::cycles_from_irvals_file;
@@ -23,6 +16,13 @@ use xlsynth_vastly::render_annotated_source;
 use xlsynth_vastly::run_pipeline_and_collect_coverage;
 use xlsynth_vastly::run_pipeline_and_write_vcd;
 use xlsynth_vastly::step_pipeline_state_with_env;
+use xlsynth_vastly::CoverageCounters;
+use xlsynth_vastly::LogicBit;
+use xlsynth_vastly::PipelineCycle;
+use xlsynth_vastly::PipelineStimulus;
+use xlsynth_vastly::Signedness;
+use xlsynth_vastly::SourceText;
+use xlsynth_vastly::Value4;
 
 #[derive(Parser, Debug)]
 #[command(name = "vastly-sim-pipeline")]
@@ -170,7 +170,11 @@ fn main_inner() -> xlsynth_vastly::Result<()> {
         let mut cov = CoverageCounters::default();
         cov.defines = defines.clone();
         for a in &m.combo.assigns {
-            cov.register_ternaries_from_spanned_expr(&a.rhs_spanned);
+            cov.register_ternaries_from_spanned_expr(
+                a.rhs_spanned
+                    .as_ref()
+                    .expect("coverage registration requires spanned assign expressions"),
+            );
         }
         cov.register_functions(&m.fn_meta);
         let cover = compute_coverability_or_fallback_with_defines(&src_text, &defines);

xlsynth-vastly/src/combo_compile.rs

@@ -2,7 +2,6 @@
 
 use std::collections::BTreeMap;
 
-use crate::Result;
 pub use crate::compiled_module::CasezArm;
 pub use crate::compiled_module::CasezPattern;
 pub use crate::compiled_module::CompiledFunction;
@@ -14,15 +13,13 @@ pub use crate::compiled_module::Port;
 pub use crate::compiled_module::PortDir;
 use crate::sv_ast::ModuleItem;
 use crate::sv_ast::ParsedModule;
+use crate::Result;
 
 pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
     let parse_src = src;
-    let parsed: ParsedModule = crate::sv_parser::parse_combo_module(parse_src)?;
-    let items = crate::generate_constructs::elaborate_combo_items(
-        parse_src,
-        &parsed.params,
-        &parsed.items,
-    )?;
+    let parsed: ParsedModule = crate::sv_parser::parse_combo_module(src)?;
+    let items =
+        crate::generate_constructs::elaborate_combo_items(src, &parsed.params, &parsed.items)?;
 
     let module_name = parsed.name;
     let (input_ports, output_ports, mut decls) = crate::compiled_module::lower_ports(&parsed.ports);
@@ -37,20 +34,16 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
         match it {
             ModuleItem::Decl { .. } => {}
             ModuleItem::Assign {
-                lhs, rhs, rhs_text, ..
+                lhs, rhs, rhs_span, ..
             } => {
                 assigns.push(crate::compiled_module::lower_assign(
-                    parse_src,
-                    lhs,
-                    *rhs,
-                    rhs_text.as_deref(),
-                    &decls,
+                    parse_src, lhs, rhs, *rhs_span, &decls, true,
                 )?);
             }
             ModuleItem::Function { func: f, .. } => {
                 functions.insert(
                     f.name.clone(),
-                    crate::compiled_module::lower_function(parse_src, f, &decls)?,
+                    crate::compiled_module::lower_function(parse_src, f, &decls, true)?,
                 );
             }
             ModuleItem::AlwaysFf { .. } => {

xlsynth-vastly/src/combo_eval.rs

@@ -4,14 +4,6 @@ use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::VecDeque;
 
-use crate::CoverageCounters;
-use crate::Env;
-use crate::Error;
-use crate::Result;
-use crate::Signedness;
-use crate::SourceText;
-use crate::SpanKey;
-use crate::Value4;
 use crate::ast::Expr;
 use crate::ast_spanned::SpannedExpr;
 use crate::ast_spanned::SpannedExprKind;
@@ -20,7 +12,6 @@ use crate::combo_compile::CasezPattern;
 use crate::combo_compile::CompiledComboModule;
 use crate::combo_compile::CompiledFunction;
 use crate::combo_compile::CompiledFunctionBody;
-use crate::eval::CallResolver;
 use crate::eval::binary_operand_expected_signednesses;
 use crate::eval::binary_operand_expected_widths;
 use crate::eval::eval_ast_with_calls;
@@ -31,10 +22,19 @@ use crate::eval::merged_signedness;
 use crate::eval::operand_with_own_sign_ctx;
 use crate::eval::replication_count_to_u32;
 use crate::eval::unary_operand_expected_width;
+use crate::eval::CallResolver;
 use crate::packed::packed_index_selection;
 use crate::packed::packed_index_selection_if_in_bounds;
 use crate::sv_ast::Lhs;
 use crate::value::LogicBit;
+use crate::CoverageCounters;
+use crate::Env;
+use crate::Error;
+use crate::Result;
+use crate::Signedness;
+use crate::SourceText;
+use crate::SpanKey;
+use crate::Value4;
 
 pub struct ComboEvalPlan {
     /// Assign indices in evaluation order.
@@ -255,8 +255,12 @@ pub fn eval_combo_seeded_with_coverage(
             .get(lhs_base)
             .ok_or_else(|| Error::Parse(format!("no decl for assign lhs `{lhs_base}`")))?;
         let expected_width = lhs_expected_write_width(&a.lhs, info)?;
+        let rhs_spanned = a
+            .rhs_spanned
+            .as_ref()
+            .expect("coverage evaluation requires spanned assign expressions");
         let rhs_v = eval_spanned_expr_with_funcs(
-            &a.rhs_spanned,
+            rhs_spanned,
             &env,
             &m.functions,
             expected_width,

xlsynth-vastly/src/combo_harness.rs

@@ -3,13 +3,13 @@
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 
-use crate::Error;
-use crate::Result;
-use crate::Value4;
 use crate::combo_compile::CompiledComboModule;
-use crate::combo_eval::ComboEvalPlan;
 use crate::combo_eval::eval_combo;
+use crate::combo_eval::ComboEvalPlan;
 use crate::vcd_writer::VcdWriter;
+use crate::Error;
+use crate::Result;
+use crate::Value4;
 
 pub fn run_combo_and_write_vcd(
     m: &CompiledComboModule,

xlsynth-vastly/src/compiled_module.rs

@@ -3,17 +3,11 @@
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 
-use crate::Error;
-use crate::LogicBit;
-use crate::Result;
-use crate::Signedness;
-use crate::Value4;
 use crate::ast::Expr;
 use crate::ast_spanned::SpannedExpr;
 use crate::packed::rewrite_packed_expr;
 use crate::packed::rewrite_packed_lhs;
 use crate::packed::rewrite_packed_spanned_expr;
-use crate::parser::parse_expr;
 use crate::parser_spanned::parse_expr_spanned;
 use crate::sv_ast::Decl;
 use crate::sv_ast::FunctionBody;
@@ -24,6 +18,11 @@ use crate::sv_ast::PortDecl;
 use crate::sv_ast::PortDir as SvPortDir;
 use crate::sv_ast::Span;
 use crate::sv_ast::Stmt;
+use crate::Error;
+use crate::LogicBit;
+use crate::Result;
+use crate::Signedness;
+use crate::Value4;
 
 pub type State = BTreeMap<String, Value4>;
 
@@ -53,7 +52,7 @@ pub struct ModuleAssign {
     pub lhs: Lhs,
     pub rhs: Expr,
     pub rhs_span: Span,
-    pub rhs_spanned: SpannedExpr,
+    pub rhs_spanned: Option<SpannedExpr>,
 }
 
 impl ModuleAssign {
@@ -212,16 +211,21 @@ pub(crate) fn extend_decls_from_items(
 pub(crate) fn lower_assign(
     parse_src: &str,
     lhs: &Lhs,
+    rhs: &Expr,
     rhs_span: Span,
-    rhs_text: Option<&str>,
     decls: &BTreeMap<String, DeclInfo>,
+    preserve_spans: bool,
 ) -> Result<ModuleAssign> {
-    let rhs_src = rhs_text.unwrap_or_else(|| parse_src[rhs_span.start..rhs_span.end].trim());
     let lhs = rewrite_packed_lhs(lhs.clone(), decls)?;
-    let rhs = rewrite_packed_expr(parse_expr(rhs_src)?, decls)?;
-    let mut rhs_spanned = parse_expr_spanned(rhs_src)?;
-    rhs_spanned.shift_spans(rhs_span.start);
-    rhs_spanned = rewrite_packed_spanned_expr(rhs_spanned, decls)?;
+    let rhs = rewrite_packed_expr(rhs.clone(), decls)?;
+    let rhs_spanned = if preserve_spans {
+        Some(rewrite_packed_spanned_expr(
+            parse_expr_spanned_in_span(parse_src, rhs_span)?,
+            decls,
+        )?)
+    } else {
+        None
+    };
     Ok(ModuleAssign {
         lhs,
         rhs,
@@ -235,6 +239,7 @@ pub(crate) fn lower_function(
     parse_src: &str,
     f: &FunctionDecl,
     decls: &BTreeMap<String, DeclInfo>,
+    preserve_spans: bool,
 ) -> Result<CompiledFunction> {
     let mut fn_decls = decls.clone();
     for arg in &f.args {
@@ -253,13 +258,10 @@ pub(crate) fn lower_function(
 
     let body = match &f.body {
         FunctionBody::UniqueCasez { selector, arms, .. } => {
-            let selector_src = parse_src[selector.start..selector.end].trim();
-            let selector = rewrite_packed_expr(parse_expr(selector_src)?, &fn_decls)?;
-
+            let selector = rewrite_packed_expr(selector.clone(), &fn_decls)?;
             let mut out_arms: Vec<CasezArm> = Vec::new();
             for a in arms {
-                let value_src = parse_src[a.value.start..a.value.end].trim();
-                let value = rewrite_packed_expr(parse_expr(value_src)?, &fn_decls)?;
+                let value = rewrite_packed_expr(a.value.clone(), &fn_decls)?;
                 let pat = a.pat.as_ref().map(|p| CasezPattern {
                     width: p.width,
                     bits_msb: p.bits_msb.clone(),
@@ -271,22 +273,22 @@ pub(crate) fn lower_function(
                 arms: out_arms,
             }
         }
-        FunctionBody::Assign { value } => {
-            let value_src = parse_src[value.start..value.end].trim();
-            let expr = rewrite_packed_expr(parse_expr(value_src)?, &fn_decls)?;
-            let mut expr_spanned = parse_expr_spanned(value_src)?;
-            expr_spanned.shift_spans(value.start);
-            expr_spanned = rewrite_packed_spanned_expr(expr_spanned, &fn_decls)?;
-            CompiledFunctionBody::Expr {
-                expr,
-                expr_spanned: Some(expr_spanned),
-            }
+        FunctionBody::Assign { value, value_span } => {
+            let expr = rewrite_packed_expr(value.clone(), &fn_decls)?;
+            let expr_spanned = if preserve_spans {
+                Some(rewrite_packed_spanned_expr(
+                    parse_expr_spanned_in_span(parse_src, *value_span)?,
+                    &fn_decls,
+                )?)
+            } else {
+                None
+            };
+            CompiledFunctionBody::Expr { expr, expr_spanned }
         }
         FunctionBody::Procedure { assigns } => {
             let mut out_assigns: Vec<FunctionAssign> = Vec::with_capacity(assigns.len());
             for a in assigns {
-                let value_src = parse_src[a.value.start..a.value.end].trim();
-                let expr = rewrite_packed_expr(parse_expr(value_src)?, &fn_decls)?;
+                let expr = rewrite_packed_expr(a.value.clone(), &fn_decls)?;
                 out_assigns.push(FunctionAssign {
                     lhs: a.lhs.clone(),
                     expr,
@@ -312,6 +314,13 @@ pub(crate) fn lower_function(
     })
 }
 
+fn parse_expr_spanned_in_span(parse_src: &str, span: Span) -> Result<SpannedExpr> {
+    let expr_src = parse_src[span.start..span.end].trim();
+    let mut spanned = parse_expr_spanned(expr_src)?;
+    spanned.shift_spans(span.start);
+    Ok(spanned)
+}
+
 fn decl_info_from_decl(d: &Decl) -> DeclInfo {
     DeclInfo {
         width: d.width,

xlsynth-vastly/src/coverability.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::SourceText;
 use crate::sv_ast::ModuleItem;
 use crate::sv_ast::Span;
+use crate::SourceText;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum LineCoverability {

xlsynth-vastly/src/coverage.rs

@@ -3,12 +3,12 @@
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 
-use crate::LogicBit;
-use crate::Value4;
 use crate::ast_spanned::SpannedExpr;
 use crate::ast_spanned::SpannedExprKind;
 use crate::pipeline_compile::FunctionMeta;
 use crate::sv_ast::Span;
+use crate::LogicBit;
+use crate::Value4;
 
 #[derive(Debug, Clone)]
 pub struct SourceText {

xlsynth-vastly/src/coverage_render2.rs

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::coverage::SpanKey;
+use crate::sv_lexer::TokKind;
 use crate::CoverabilityMap;
 use crate::CoverageCounters;
 use crate::SourceText;
-use crate::coverage::SpanKey;
-use crate::sv_lexer::TokKind;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum LineClass {