Skip to content

[vastly] Add support for packed arrays. #862

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
meheff merged 2 commits into from
Mar 7, 2026
Merged

[vastly] Add support for packed arrays. #862

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
a9ffba3
Add support for packed arrays.
meheff Mar 6, 2026
2a61916
Address review comments.
meheff Mar 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
139 changes: 108 additions & 31 deletions xlsynth-vastly/src/combo_compile.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,12 +9,16 @@ use crate::ast::Expr;
use crate::ast_spanned::SpannedExpr;
use crate::ast_spanned::SpannedExprKind;
use crate::module_compile::DeclInfo;
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::ComboFunctionBody;
use crate::sv_ast::ComboItem;
use crate::sv_ast::ComboModule;
use crate::sv_ast::Decl;
use crate::sv_ast::Lhs;
use crate::sv_ast::PortDir as SvPortDir;
use crate::sv_ast::Span;

Expand All @@ -33,12 +37,23 @@ pub struct Port {

#[derive(Debug, Clone)]
pub struct ComboAssign {
pub lhs: String,
pub lhs: Lhs,
pub rhs: Expr,
pub rhs_span: Span,
pub rhs_spanned: SpannedExpr,
}

impl ComboAssign {
pub fn lhs_base(&self) -> &str {
match &self.lhs {
Lhs::Ident(base) => base,
Lhs::Index { base, .. } => base,
Lhs::PackedIndex { base, .. } => base,
Lhs::Slice { base, .. } => base,
}
}
}

#[derive(Debug, Clone)]
pub struct CasezPattern {
pub width: u32,
Expand Down Expand Up @@ -129,14 +144,7 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
}
decls.insert(
normalized.denormalize_ident(&p.name),
DeclInfo {
width: p.width,
signedness: if p.signed {
Signedness::Signed
} else {
Signedness::Unsigned
},
},
decl_info_from_port_decl(p),
);
}

Expand All @@ -148,31 +156,48 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
ComboItem::WireDecl(d) => {
decls.insert(
normalized.denormalize_ident(&d.name),
DeclInfo {
width: d.width,
signedness: if d.signed {
Signedness::Signed
} else {
Signedness::Unsigned
},
},
decl_info_from_decl(d),
);
}
ComboItem::Assign { lhs_ident, rhs } => {
ComboItem::Assign { .. } | ComboItem::Function(_) => {}
}
}

for it in &parsed.items {
match it {
ComboItem::WireDecl(_) => {}
ComboItem::Assign { lhs, rhs } => {
let rhs_src = parse_src[rhs.start..rhs.end].trim();
let rhs_expr =
denormalize_expr(parse_expr(rhs_src)?, &normalized.placeholder_to_original);
let rhs_expr = rewrite_packed_expr(rhs_expr, &decls)?;
let mut rhs_spanned = parse_expr_spanned(rhs_src)?;
denormalize_spanned_expr(&mut rhs_spanned, &normalized.placeholder_to_original);
rhs_spanned.shift_spans(rhs.start);
rhs_spanned = rewrite_packed_spanned_expr(rhs_spanned, &decls)?;
let lhs = denormalize_lhs(lhs.clone(), &normalized.placeholder_to_original);
let lhs = rewrite_packed_lhs(lhs, &decls)?;
assigns.push(ComboAssign {
lhs: normalized.denormalize_ident(lhs_ident),
lhs,
rhs: rhs_expr,
rhs_span: *rhs,
rhs_spanned,
});
}
ComboItem::Function(f) => {
let mut fn_decls = decls.clone();
for arg in &f.args {
fn_decls.insert(
normalized.denormalize_ident(&arg.name),
decl_info_from_decl(arg),
);
}
for local in &f.locals {
fn_decls.insert(
normalized.denormalize_ident(&local.name),
decl_info_from_decl(local),
);
}
let args: Vec<FunctionVar> =
f.args.iter().map(lower_decl_to_function_var).collect();
let locals: BTreeMap<String, DeclInfo> = f
Expand All @@ -189,18 +214,26 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
let body = match &f.body {
ComboFunctionBody::UniqueCasez { selector, arms, .. } => {
let selector_src = parse_src[selector.start..selector.end].trim();
let selector_expr = denormalize_expr(
parse_expr(selector_src)?,
&normalized.placeholder_to_original,
let selector_expr = rewrite_packed_expr(
denormalize_expr(
parse_expr(selector_src)?,
&normalized.placeholder_to_original,
),
&fn_decls,
);
let selector_expr = selector_expr?;

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_expr = denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
let value_expr = rewrite_packed_expr(
denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
),
&fn_decls,
);
let value_expr = value_expr?;
let pat = a.pat.as_ref().map(|p| CasezPattern {
width: p.width,
bits_msb: p.bits_msb.clone(),
Expand All @@ -217,16 +250,21 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
}
ComboFunctionBody::Assign { value } => {
let value_src = parse_src[value.start..value.end].trim();
let expr = denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
let expr = rewrite_packed_expr(
denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
),
&fn_decls,
);
let expr = expr?;
let mut expr_spanned = parse_expr_spanned(value_src)?;
denormalize_spanned_expr(
&mut expr_spanned,
&normalized.placeholder_to_original,
);
expr_spanned.shift_spans(value.start);
expr_spanned = rewrite_packed_spanned_expr(expr_spanned, &fn_decls)?;
ComboFunctionImpl::Expr {
expr,
expr_spanned: Some(expr_spanned),
Expand All @@ -236,10 +274,14 @@ pub fn compile_combo_module(src: &str) -> Result<CompiledComboModule> {
let mut out_assigns = Vec::with_capacity(assigns.len());
for a in assigns {
let value_src = parse_src[a.value.start..a.value.end].trim();
let expr = denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
let expr = rewrite_packed_expr(
denormalize_expr(
parse_expr(value_src)?,
&normalized.placeholder_to_original,
),
&fn_decls,
);
let expr = expr?;
out_assigns.push(FunctionAssign {
lhs: normalized.denormalize_ident(&a.lhs),
expr,
Expand Down Expand Up @@ -295,6 +337,19 @@ fn decl_info_from_decl(d: &Decl) -> DeclInfo {
} else {
Signedness::Unsigned
},
packed_dims: d.packed_dims.clone(),
}
}

fn decl_info_from_port_decl(p: &crate::sv_ast::PortDecl) -> DeclInfo {
DeclInfo {
width: p.width,
signedness: if p.signed {
Signedness::Signed
} else {
Signedness::Unsigned
},
packed_dims: p.packed_dims.clone(),
}
}

Expand Down Expand Up @@ -889,6 +944,28 @@ fn denormalize_expr(expr: Expr, placeholders: &BTreeMap<String, String>) -> Expr
}
}

fn denormalize_lhs(lhs: Lhs, placeholders: &BTreeMap<String, String>) -> Lhs {
match lhs {
Lhs::Ident(name) => Lhs::Ident(placeholders.get(&name).cloned().unwrap_or(name)),
Lhs::Index { base, index } => Lhs::Index {
base: placeholders.get(&base).cloned().unwrap_or(base),
index: denormalize_expr(index, placeholders),
},
Lhs::PackedIndex { base, indices } => Lhs::PackedIndex {
base: placeholders.get(&base).cloned().unwrap_or(base),
indices: indices
.into_iter()
.map(|e| denormalize_expr(e, placeholders))
.collect(),
},
Lhs::Slice { base, msb, lsb } => Lhs::Slice {
base: placeholders.get(&base).cloned().unwrap_or(base),
msb: denormalize_expr(msb, placeholders),
lsb: denormalize_expr(lsb, placeholders),
},
}
}

fn denormalize_spanned_expr(expr: &mut SpannedExpr, placeholders: &BTreeMap<String, String>) {
match &mut expr.kind {
SpannedExprKind::Ident(name) => {
Expand Down
Loading
Loading