analyzer/sim: fast and compact handling of large arrays

Two large-memory testbench arrays (e.g. `var dram: logic<32>[8M]`)
previously dominated both analyze_pass2 CPU time and RSS in the IR.

pass2 speedup:
- AssignDestination: skip full-range iteration when the index is
  non-const and total_array > evaluate_array_limit.
- Factor::eval_assign: avoid cloning the full Variable for
  large-array references (insert_reference bails anyway).

Compact storage:
- `var` / port / let initializers (all-same x-state) store a single
  template Value instead of N copies; `const` / `param` with
  `'{...}` literals keep per-element values.
- Variable::new derives `assigned` length from r#type.total_array()
  and skips allocation for arrays past evaluate_array_limit.
- fmt::Display replicates the template across total_array().
- Simulator mirrors via `v.value.len() < total_array`.

heliodor linux_boot: pass2 75 s -> 27 s, Max RSS 3.5 GB -> 2.2 GB.

Author: dalance

crates/analyzer/src/conv/declaration.rs

@@ -319,6 +319,7 @@ impl Conv<&GenerateForDeclaration> for ir::DeclarationBlock {
 
             let block = context.block(|c| {
                 let id = c.insert_var_path(path.clone(), comptime.clone());
+                let array_limit = c.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path,
@@ -327,6 +328,7 @@ impl Conv<&GenerateForDeclaration> for ir::DeclarationBlock {
                     vec![comptime.get_value().unwrap().clone()],
                     c.get_affiliation(),
                     &token,
+                    array_limit,
                 );
                 c.insert_variable(id, variable);
 
@@ -561,6 +563,7 @@ impl Conv<&PortDeclarationItem> for () {
 
                 // TODO for array
                 let id = context.insert_var_path(path.clone(), comptime);
+                let array_limit = context.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path,
@@ -569,6 +572,7 @@ impl Conv<&PortDeclarationItem> for () {
                     vec![value.clone()],
                     context.get_affiliation(),
                     &variable_token,
+                    array_limit,
                 );
                 context.insert_variable(id, variable);
             } else {
@@ -981,17 +985,17 @@ impl Conv<(&FunctionDeclaration, Option<&FuncPath>)> for () {
                     let kind = VarKind::Variable;
                     let r#type = ret_type.r#type.clone();
 
-                    if let Some(total_array) = r#type.total_array()
+                    if let Some(_total_array) = r#type.total_array()
                         && let Some(total_width) = r#type.total_width()
                     {
                         // type.expand is not necessary
                         // because member access is not allowed for return value
-                        let mut values = vec![];
-                        for _ in 0..total_array {
-                            values.push(Value::new_x(total_width, false));
-                        }
+                        // All elements are initialized to the same x-state
+                        // value, so a single template suffices.
+                        let values = vec![Value::new_x(total_width, false)];
 
                         let ret_id = c.insert_var_path(path.clone(), ret_type.clone());
+                        let array_limit = c.config.evaluate_array_limit;
                         let variable = Variable::new(
                             ret_id,
                             path,
@@ -1000,6 +1004,7 @@ impl Conv<(&FunctionDeclaration, Option<&FuncPath>)> for () {
                             values,
                             c.get_affiliation(),
                             &token,
+                            array_limit,
                         );
                         c.insert_variable(ret_id, variable);
                         Some(ret_id)

crates/analyzer/src/conv/statement.rs

@@ -704,6 +704,7 @@ fn unroll_for(
             }
 
             let id = c.insert_var_path(path.clone(), comptime.clone());
+            let array_limit = c.config.evaluate_array_limit;
             let variable = ir::Variable::new(
                 id,
                 path,
@@ -712,6 +713,7 @@ fn unroll_for(
                 vec![comptime.get_value().unwrap().clone()],
                 c.get_affiliation(),
                 &token,
+                array_limit,
             );
             c.insert_variable(id, variable);
 

crates/analyzer/src/conv/utils.rs

@@ -630,6 +630,7 @@ pub fn eval_const_assign(
             if let Some(exprs) = exprs {
                 let values = eval_array_literal_expressions(context, r#type, exprs, token)?;
                 let id = context.insert_var_path(path.clone(), comptime);
+                let array_limit = context.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path.clone(),
@@ -638,6 +639,7 @@ pub fn eval_const_assign(
                     values,
                     context.get_affiliation(),
                     &dst.token,
+                    array_limit,
                 );
                 context.insert_variable(id, variable);
             } else {
@@ -667,6 +669,7 @@ pub fn eval_const_assign(
                         value.trunc(total_width);
                     }
 
+                    let array_limit = context.config.evaluate_array_limit;
                     let variable = Variable::new(
                         id,
                         path.clone(),
@@ -675,6 +678,7 @@ pub fn eval_const_assign(
                         vec![value],
                         context.get_affiliation(),
                         &dst.token,
+                        array_limit,
                     );
                     context.insert_variable(id, variable);
                 }
@@ -709,14 +713,12 @@ pub fn eval_variable(
     let signed = comptime.r#type.signed;
     let id = context.insert_var_path(path.clone(), comptime);
 
-    let values = if let Some(total_array) = r#type.total_array()
-        && let Some(total_width) = r#type.total_width()
-    {
-        let mut values = vec![];
-        for _ in 0..total_array {
-            values.push(Value::new_x(total_width, signed));
-        }
-        values
+    // Every element starts as the same x-state template, so store it once;
+    // the simulator replicates it across the full `r#type.total_array()` at
+    // fill time. Const/param arrays with per-element literals go through
+    // `eval_array_literal` instead and keep their Vec<Value> intact.
+    let values = if let Some(total_width) = r#type.total_width() {
+        vec![Value::new_x(total_width, signed)]
     } else {
         vec![]
     };
@@ -729,6 +731,7 @@ pub fn eval_variable(
         context.insert_var_path_with_id(path, id, comptime);
     }
 
+    let array_limit = context.config.evaluate_array_limit;
     let variable = Variable::new(
         id,
         path.clone(),
@@ -737,6 +740,7 @@ pub fn eval_variable(
         values,
         context.get_affiliation(),
         &token,
+        array_limit,
     );
     context.insert_variable(id, variable);
 }
@@ -1438,6 +1442,7 @@ pub fn build_for_statement(
     } else {
         vec![]
     };
+    let array_limit = context.config.evaluate_array_limit;
     let variable = Variable::new(
         loop_var_id,
         path,
@@ -1446,6 +1451,7 @@ pub fn build_for_statement(
         values,
         context.get_affiliation(),
         &token,
+        array_limit,
     );
     context.insert_variable(loop_var_id, variable);
 

crates/analyzer/src/ir/assign_table.rs

@@ -444,6 +444,7 @@ mod tests {
             vec![],
             Affiliation::Module,
             &TokenRange::default(),
+            context.config.evaluate_array_limit,
         );
         let variable = VariableInfo::new(&variable);
 

crates/analyzer/src/ir/expression.rs

@@ -733,6 +733,17 @@ impl Factor {
     ) {
         match self {
             Factor::Variable(id, index, select, _) => {
+                // `insert_reference` bails out on arrays over `array_limit`;
+                // short-circuit to avoid cloning the full Variable (value
+                // vec scales with array size).
+                let total_array = context
+                    .variables
+                    .get(id)
+                    .map(|v| v.r#type.total_array().unwrap_or(0))
+                    .unwrap_or(0);
+                if total_array > assign_table.array_limit {
+                    return;
+                }
                 if let Some(index) = index.eval_value(context)
                     && let Some(variable) = context.variables.get(id).cloned()
                     && let Some((beg, end)) = select.eval_value(context, &variable.r#type, false)

crates/analyzer/src/ir/statement.rs

@@ -465,28 +465,38 @@ impl AssignDestination {
 
             let mut errors = vec![];
             if let Some((beg, end)) = range {
-                for i in beg..=end {
-                    let index = VarIndex::from_index(i, &variable.r#type.array);
-                    if let Some(index) = index.eval_value(context) {
-                        if assign_context.is_comb()
-                            && assign_table.check_refered(&variable.id, &index, &mask)
-                        {
-                            let mut text = variable.path.to_string();
-                            for i in &index {
-                                text.push_str(&format!("[{i}]"));
+                // `insert_assign` / `check_refered` both bail out on arrays
+                // over `array_limit`; iterating beg..=end just to hit that
+                // guard is pure waste when the index is non-const.
+                let array_size = end.saturating_sub(beg).saturating_add(1);
+                let skip_large_array = !is_index_const
+                    && variable.r#type.total_array().unwrap_or(0) > assign_table.array_limit
+                    && array_size > assign_table.array_limit;
+
+                if !skip_large_array {
+                    for i in beg..=end {
+                        let index = VarIndex::from_index(i, &variable.r#type.array);
+                        if let Some(index) = index.eval_value(context) {
+                            if assign_context.is_comb()
+                                && assign_table.check_refered(&variable.id, &index, &mask)
+                            {
+                                let mut text = variable.path.to_string();
+                                for i in &index {
+                                    text.push_str(&format!("[{i}]"));
+                                }
+                                // ignore `#[allow(unassign_variable)]` attribute
+                                errors.push(AnalyzerError::unassign_variable(&text, &self.token));
                             }
-                            // ignore `#[allow(unassign_variable)]` attribute
-                            errors.push(AnalyzerError::unassign_variable(&text, &self.token));
-                        }
 
-                        let maybe = !is_const | assign_context.is_system_verilog();
-                        let _ = assign_table.insert_assign(
-                            &variable,
-                            index,
-                            mask.clone(),
-                            maybe,
-                            self.token,
-                        );
+                            let maybe = !is_const | assign_context.is_system_verilog();
+                            let _ = assign_table.insert_assign(
+                                &variable,
+                                index,
+                                mask.clone(),
+                                maybe,
+                                self.token,
+                            );
+                        }
                     }
                 }
             }

crates/analyzer/src/ir/variable.rs

@@ -741,6 +741,7 @@ pub struct Variable {
 }
 
 impl Variable {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         id: VarId,
         path: VarPath,
@@ -749,11 +750,19 @@ impl Variable {
         value: Vec<Value>,
         affiliation: Affiliation,
         token: &TokenRange,
+        array_limit: usize,
     ) -> Self {
-        let mut assigned = vec![];
-        for _ in 0..value.len() {
-            assigned.push(0u32.into());
-        }
+        // `assigned` tracks per-element coverage and must match the full
+        // array length (not `value.len()`, since `value` may hold a single
+        // template entry for all-same init). `set_assigned` / `unassigned()`
+        // callers gate on `> array_limit` before touching `assigned`, so
+        // arrays past the limit can leave the vec empty.
+        let total_array = r#type.total_array().unwrap_or(value.len()).max(value.len());
+        let assigned: Vec<BigUint> = if total_array > array_limit {
+            Vec::new()
+        } else {
+            vec![0u32.into(); total_array]
+        };
 
         Self {
             id,
@@ -866,8 +875,23 @@ impl fmt::Display for Variable {
         }
         r#type.array.clear();
 
-        let is_array = self.value.len() != 1;
-        for (i, value) in self.value.iter().enumerate() {
+        // Template form (`value.len() == 1 && total_array > 1`) means every
+        // element shares value[0]; otherwise treat value.len() as the
+        // effective element count.
+        let type_len = self.r#type.total_array();
+        let is_template = self.value.len() == 1 && matches!(type_len, Some(n) if n > 1);
+        let display_len = if is_template {
+            type_len.unwrap()
+        } else {
+            self.value.len()
+        };
+        let is_array = display_len != 1;
+        for i in 0..display_len {
+            let value = if is_template {
+                &self.value[0]
+            } else {
+                &self.value[i]
+            };
             if is_array {
                 ret.push_str(&format!(
                     "{} {}[{}]({}): ",

crates/simulator/src/ir/module.rs

@@ -84,7 +84,18 @@ fn fill_buffers_recursive(
     sorted.sort_by_key(|(k, _)| **k);
 
     for (_, meta) in &sorted {
-        for (element, initial) in meta.elements.iter().zip(meta.initial_values.iter()) {
+        // Single-entry initial_values on a multi-element variable is the
+        // compact template form used for large arrays.
+        let template_mode = meta.initial_values.len() == 1 && meta.elements.len() > 1;
+        for (i, element) in meta.elements.iter().enumerate() {
+            let initial = if template_mode {
+                &meta.initial_values[0]
+            } else {
+                match meta.initial_values.get(i) {
+                    Some(v) => v,
+                    None => continue,
+                }
+            };
             let nb = element.native_bytes;
             let _vs = value_size(nb, use_4state);
             if element.is_ff() {

crates/simulator/src/ir/variable.rs

@@ -317,25 +317,30 @@ pub fn create_variable_meta(
         let nb = native_bytes(width);
         let vs = value_size(nb, use_4state);
 
+        // Analyzer collapses all-same initial arrays down to a single
+        // template value (eval_variable), so derive the real array length
+        // from the type.
+        let total_array = v.r#type.total_array().unwrap_or(v.value.len());
+        let total_array = total_array.max(v.value.len()).max(1);
+
         // For multi-element variables (arrays), all elements must have the
         // same FF/comb classification. DynamicVariable expressions assume
         // uniform stride in a single buffer; mixed placement is invalid.
-        let any_ff = v
-            .value
-            .iter()
-            .enumerate()
-            .any(|(i, _)| ff_table.is_ff(v.id, i));
-        let force_ff = any_ff && v.value.len() > 1;
-
-        let mut elements = vec![];
-        let mut initial_values = vec![];
-
-        for (i, val) in v.value.iter().enumerate() {
-            let mut val = val.clone();
-            if !use_4state {
-                val.clear_xz();
-            }
+        let any_ff = (0..total_array).any(|i| ff_table.is_ff(v.id, i));
+        let force_ff = any_ff && total_array > 1;
+
+        // `v.value.len() < total_array` means the analyzer supplied only
+        // the template entry — replicate it across all elements.
+        let template_mode = v.value.len() < total_array;
+
+        let mut elements = Vec::with_capacity(total_array);
+        let mut initial_values = if template_mode {
+            Vec::with_capacity(1)
+        } else {
+            Vec::with_capacity(total_array)
+        };
 
+        for i in 0..total_array {
             if force_ff || ff_table.is_ff(v.id, i) {
                 let current_offset = ff_pos;
                 let next_offset = ff_pos + vs as isize;
@@ -355,6 +360,20 @@ pub fn create_variable_meta(
                 comb_pos += vs as isize;
             }
 
+            if template_mode && i > 0 {
+                continue;
+            }
+            let raw = if let Some(val) = v.value.get(i) {
+                val.clone()
+            } else if let Some(template) = v.value.first() {
+                template.clone()
+            } else {
+                Value::new_x(width, v.r#type.signed)
+            };
+            let mut val = raw;
+            if !use_4state {
+                val.clear_xz();
+            }
             initial_values.push(val);
         }