[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

@@ -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

@@ -17,12 +17,9 @@ use crate::sv_ast::ParsedModule;
 
 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,25 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
         match it {
             ModuleItem::Decl { .. } => {}
             ModuleItem::Assign {
-                lhs, rhs, rhs_text, ..
+                lhs,
+                rhs,
+                rhs_spanned,
+                rhs_span,
+                ..
             } => {
                 assigns.push(crate::compiled_module::lower_assign(
-                    parse_src,
                     lhs,
-                    *rhs,
-                    rhs_text.as_deref(),
+                    rhs,
+                    rhs_spanned,
+                    *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

@@ -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/compiled_module.rs

@@ -13,7 +13,6 @@ 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;
@@ -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 {
@@ -210,18 +209,20 @@ pub(crate) fn extend_decls_from_items(
 
 /// Lowers an assign item using packed rewrites and span-preserving parsed AST.
 pub(crate) fn lower_assign(
-    parse_src: &str,
     lhs: &Lhs,
+    rhs: &Expr,
+    rhs_spanned: &SpannedExpr,
     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(rhs_spanned.clone(), decls)?)
+    } else {
+        None
+    };
     Ok(ModuleAssign {
         lhs,
         rhs,
@@ -235,6 +236,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 +255,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 +270,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 +311,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/eval.rs

@@ -41,15 +41,9 @@ pub(crate) fn operand_with_own_sign_ctx(
     expected_width: Option<u32>,
     expected_signedness: Option<Signedness>,
 ) -> Value4 {
-    let v = if let Some(signedness) = expected_signedness {
-        v.with_signedness(signedness)
-    } else {
-        v
-    };
-    let Some(width) = expected_width else {
-        return v;
-    };
-    if width <= v.width { v } else { v.resize(width) }
+    let signedness = expected_signedness.unwrap_or(v.signedness);
+    let width = expected_width.unwrap_or(v.width).max(v.width);
+    v.into_width_and_signedness(width, signedness)
 }
 
 pub(crate) fn replication_count_to_u32(v: &Value4) -> Result<u32> {
@@ -75,8 +69,8 @@ fn operand_with_merged_sign_ctx(
 ) -> (Value4, Value4) {
     let width = expected_width.unwrap_or(0).max(lhs.width.max(rhs.width));
     let signedness = expected_signedness.unwrap_or_else(|| merged_signedness(&lhs, &rhs));
-    let lhs = lhs.with_signedness(signedness).resize(width);
-    let rhs = rhs.with_signedness(signedness).resize(width);
+    let lhs = lhs.into_width_and_signedness(width, signedness);
+    let rhs = rhs.into_width_and_signedness(width, signedness);
     (lhs, rhs)
 }