use std::collections::{BTreeMap, BTreeSet};
use xlsynth::vast_helpers::{RegisterDefinition, RegisterScope, Reset};
use xlsynth_pir::ir::{
Binop, Block, BlockPort, InstantiationKind, MemberType, NodePayload, NodeRef, Package,
PackageMember, Register, Type, Unop,
};
use xlsynth_pir::ir_utils::{get_topological, operands};
use xlsynth_pir::ir_verify::verify_package;
use xlsynth_pir::{IrFormatPreference, IrValue};
use xlsynth_vast::{
Expr, IndexableExpr, LiteralFormat, LogicRef, VastDataType, VastFile, VastFileType, VastModule,
};
use crate::stages::{Stage, reconstruct_stages};
use crate::{BlockCodegenError, BlockCodegenOptions, BlockCodegenOutput, Layout};
#[derive(Clone, Copy, Debug)]
pub(crate) struct Value {
pub(crate) expr: Expr,
pub(crate) indexable: Option<IndexableExpr>,
pub(crate) depth: usize,
pub(crate) bit_width: Option<usize>,
pub(crate) static_origin: Option<(IndexableExpr, usize)>,
pub(crate) array_rank: usize,
}
struct ResettableRegisterGroup {
signal: Expr,
registers: Vec<RegisterDefinition>,
}
impl Value {
pub(crate) fn signal(signal: LogicRef) -> Self {
let indexable = signal.to_indexable_expr();
Self {
expr: signal.to_expr(),
indexable: Some(indexable),
depth: 0,
bit_width: None,
static_origin: Some((indexable, 0)),
array_rank: 0,
}
}
pub(crate) fn expression(expr: Expr, depth: usize) -> Self {
Self {
expr,
indexable: None,
depth,
bit_width: None,
static_origin: None,
array_rank: 0,
}
}
pub(crate) fn static_slice(expr: Expr, source: Self, start: usize, width: usize) -> Self {
Self {
expr,
indexable: None,
depth: source.depth + 1,
bit_width: Some(width),
static_origin: source
.static_origin
.map(|(origin, offset)| (origin, offset + start)),
array_rank: 0,
}
}
pub(crate) fn with_width(mut self, bit_width: usize) -> Self {
self.bit_width = Some(bit_width);
self
}
pub(crate) fn with_type(mut self, mut ty: &Type) -> Self {
self.bit_width = Some(ty.bit_count());
self.array_rank = 0;
while let Type::Array(array) = ty {
self.array_rank += 1;
ty = &array.element_type;
}
if self.array_rank != 0 {
self.static_origin = None;
}
self
}
}
pub(crate) struct BlockEmitter<'a, 'file> {
pub(crate) package: &'a Package,
pub(crate) options: &'a BlockCodegenOptions,
pub(crate) block: &'a Block,
pub(crate) file: &'file mut VastFile,
pub(crate) module: VastModule,
pub(crate) values: Vec<Option<Value>>,
pub(crate) ports: BTreeMap<String, LogicRef>,
pub(crate) register_refs: BTreeMap<String, LogicRef>,
pub(crate) users: Vec<Vec<NodeRef>>,
pub(crate) names: BTreeSet<String>,
pub(crate) genvar_names: BTreeMap<usize, String>,
pub(crate) priority_helpers: BTreeMap<crate::priority::PriorityHelper, String>,
pub(crate) arithmetic_helpers: BTreeMap<crate::arithmetic::ArithmeticHelper, String>,
pub(crate) slice_helpers: BTreeMap<crate::slicing::SliceHelper, String>,
pub(crate) current_stage: Option<usize>,
pub(crate) instance_inputs: BTreeMap<(String, String), Expr>,
pub(crate) instance_outputs: BTreeMap<(String, String), Expr>,
}
pub(crate) fn emit_package(
package: &Package,
options: &BlockCodegenOptions,
) -> Result<BlockCodegenOutput, BlockCodegenError> {
let top = select_top(package, options.top.as_deref())?;
verify_package(package).map_err(|error| BlockCodegenError::InvalidBlock(error.to_string()))?;
let mut ordered = Vec::new();
let mut visited = BTreeSet::new();
let mut visiting = BTreeSet::new();
collect_dependencies(package, top, &mut ordered, &mut visited, &mut visiting)?;
for &block in &ordered {
validate_single_register_writes(block)?;
}
crate::hierarchy::verify_hierarchy(&ordered)?;
if let Some(module_name) = options.module_name.as_deref()
&& ordered
.iter()
.any(|block| block.name != top && block.name == module_name)
{
return Err(BlockCodegenError::InvalidBlock(format!(
"top module name `{module_name}` conflicts with an instantiated child block; \
choose a distinct module name"
)));
}
let mut file = VastFile::new(VastFileType::SystemVerilog);
for block in ordered {
let module_name = if block.name == top {
options.module_name.as_deref().unwrap_or(&block.name)
} else {
&block.name
};
validate_external_identifier(module_name, "module")?;
let module = file.add_module(module_name);
let mut emitter = BlockEmitter::new(package, options, block, &mut file, module);
emitter.emit()?;
}
Ok(BlockCodegenOutput {
system_verilog: file.emit(),
})
}
fn validate_single_register_writes(block: &Block) -> Result<(), BlockCodegenError> {
let mut write_counts = BTreeMap::<&str, usize>::new();
for node in &block.nodes {
if let NodePayload::RegisterWrite { register, .. } = &node.payload {
*write_counts.entry(register.as_str()).or_default() += 1;
}
}
for register in &block.registers {
let writes = write_counts[register.name.as_str()];
if writes != 1 {
return Err(BlockCodegenError::InvalidBlock(format!(
"register `{}` in block `{}` requires exactly one write, found {writes}",
register.name, block.name
)));
}
}
Ok(())
}
fn validate_supported_nodes(block: &Block) -> Result<(), BlockCodegenError> {
if block
.nodes
.iter()
.any(|node| matches!(node.payload, NodePayload::CountedFor { .. }))
{
return Err(BlockCodegenError::Unsupported(format!(
"counted_for is not supported in `{}`; unroll loops before block2sv code generation",
block.name
)));
}
if block
.nodes
.iter()
.any(|node| matches!(node.payload, NodePayload::Invoke { .. }))
{
return Err(BlockCodegenError::Unsupported(format!(
"invoke is not supported in `{}`; inline function calls before block2sv code generation",
block.name
)));
}
Ok(())
}
fn select_top<'a>(
package: &'a Package,
explicit_top: Option<&str>,
) -> Result<&'a str, BlockCodegenError> {
let blocks = package
.members
.iter()
.filter_map(|member| match member {
PackageMember::Block(block) => Some(block.name.as_str()),
PackageMember::Function(_) => None,
})
.collect::<Vec<_>>();
if let Some(requested) = explicit_top {
return blocks
.into_iter()
.find(|name| *name == requested)
.ok_or_else(|| {
BlockCodegenError::TopSelection(format!(
"requested top block `{requested}` does not exist"
))
});
}
if let Some((name, MemberType::Block)) = &package.top {
return blocks
.into_iter()
.find(|candidate| candidate == &name.as_str())
.ok_or_else(|| {
BlockCodegenError::TopSelection(format!(
"package top block `{name}` does not exist"
))
});
}
match blocks.as_slice() {
[only] => Ok(only),
[] => Err(BlockCodegenError::TopSelection(
"package contains no block suitable for SystemVerilog generation".to_owned(),
)),
_ => Err(BlockCodegenError::TopSelection(format!(
"package contains multiple blocks ({}) without a block top; specify --top",
blocks.join(", ")
))),
}
}
fn collect_dependencies<'a>(
package: &'a Package,
name: &'a str,
ordered: &mut Vec<&'a Block>,
visited: &mut BTreeSet<&'a str>,
visiting: &mut BTreeSet<&'a str>,
) -> Result<(), BlockCodegenError> {
if visited.contains(name) {
return Ok(());
}
if !visiting.insert(name) {
return Err(BlockCodegenError::InvalidBlock(format!(
"block instantiation cycle includes `{name}`"
)));
}
let block = package
.members
.iter()
.find_map(|member| match member {
PackageMember::Block(block) if block.name == name => Some(block),
_ => None,
})
.ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"instantiated block `{name}` does not exist in the package"
))
})?;
for instance in &block.instantiations {
if instance.kind == InstantiationKind::Block {
collect_dependencies(package, &instance.block, ordered, visited, visiting)?;
}
}
visiting.remove(name);
visited.insert(name);
ordered.push(block);
Ok(())
}
impl<'a, 'file> BlockEmitter<'a, 'file> {
fn new(
package: &'a Package,
options: &'a BlockCodegenOptions,
block: &'a Block,
file: &'file mut VastFile,
module: VastModule,
) -> Self {
let mut users = vec![Vec::new(); block.nodes.len()];
for (index, node) in block.nodes.iter().enumerate() {
for operand in operands(&node.payload) {
users[operand.index].push(NodeRef { index });
}
}
Self {
package,
options,
block,
file,
module,
values: vec![None; block.nodes.len()],
ports: BTreeMap::new(),
register_refs: BTreeMap::new(),
users,
names: BTreeSet::new(),
genvar_names: BTreeMap::new(),
priority_helpers: BTreeMap::new(),
arithmetic_helpers: BTreeMap::new(),
slice_helpers: BTreeMap::new(),
current_stage: None,
instance_inputs: BTreeMap::new(),
instance_outputs: BTreeMap::new(),
}
}
fn emit(&mut self) -> Result<(), BlockCodegenError> {
validate_supported_nodes(self.block)?;
self.reserve_fixed_names()?;
self.emit_ports()?;
self.emit_arithmetic_helpers()?;
self.emit_slice_helpers()?;
self.emit_priority_helpers(self.block)?;
match self.options.layout {
Layout::None => self.emit_flat()?,
Layout::Pipeline => self.emit_pipeline()?,
}
self.emit_outputs()?;
self.emit_instantiations()?;
Ok(())
}
fn reserve_fixed_names(&mut self) -> Result<(), BlockCodegenError> {
let mut fixed_names = BTreeMap::new();
let mut reserve = |name: &str, kind: &'static str| {
validate_external_identifier(name, kind)?;
if let Some(previous) = fixed_names.insert(name.to_owned(), kind) {
return Err(BlockCodegenError::InvalidBlock(format!(
"SystemVerilog name collision in block `{}`: `{name}` is used by both {previous} and {kind}",
self.block.name
)));
}
Ok(())
};
if let Some(clock) = self.block.clock_port_name() {
reserve(clock, "port")?;
}
for port in self.block.input_ports().chain(self.block.output_ports()) {
if self.block.port_type(port).bit_count() != 0 {
reserve(self.block.port_name(port), "port")?;
}
}
for instance in &self.block.instantiations {
reserve(&instance.name, "instance")?;
}
for node in &self.block.nodes {
match &node.payload {
NodePayload::Assert { label, .. }
if self.options.emit_asserts && !label.is_empty() =>
{
reserve(label, "assertion label")?;
}
NodePayload::Cover { label, .. } => reserve(label, "coverage label")?,
_ => {
}
}
}
self.names.extend(fixed_names.into_keys());
Ok(())
}
fn emit_ports(&mut self) -> Result<(), BlockCodegenError> {
for port in &self.block.ports {
let (name, ir_type, sv_type, is_output) = match port {
BlockPort::Clock(name) => (name.clone(), Type::Bits(1), None, false),
BlockPort::Input(node) | BlockPort::Output(node) => {
let sv_type = match &self.block.get_node(*node).payload {
NodePayload::InputPort { sv_type, .. }
| NodePayload::OutputPort { sv_type, .. } => sv_type.as_deref(),
_ => unreachable!("verified block data port"),
};
(
self.block.port_name(*node).to_string(),
self.block.port_type(*node).clone(),
sv_type,
matches!(port, BlockPort::Output(_)),
)
}
};
if self.ports.contains_key(&name) {
continue;
}
let width = ir_type.bit_count();
if width == 0 {
continue;
}
validate_external_identifier(&name, "port")?;
let data_type = if self.options.emit_sv_types {
if let Some(sv_type) = sv_type {
if let Some((package, ty)) = sv_type.rsplit_once("::") {
self.file.make_extern_package_type(package, ty)
} else {
self.file.make_extern_type(sv_type)
}
} else {
self.value_type(&ir_type)
}
} else {
self.value_type(&ir_type)
};
let signal = if is_output {
self.file.add_logic_output(self.module, &name, &data_type)
} else {
self.file.add_logic_input(self.module, &name, &data_type)
};
self.ports.insert(name, signal);
}
for (index, node) in self.block.nodes.iter().enumerate() {
if let NodePayload::InputPort { name, sv_type } = &node.payload {
if let Some(signal) = self.ports.get(name).copied() {
let value = Value::signal(signal).with_width(node.ty.bit_count());
self.values[index] = Some(if self.options.emit_sv_types && sv_type.is_some() {
value
} else {
value.with_type(&node.ty)
});
}
}
}
Ok(())
}
fn emit_flat(&mut self) -> Result<(), BlockCodegenError> {
let start = self.file.module_member_count(self.module);
self.emit_input_array_views()?;
for register in &self.block.registers {
self.declare_register(register)?;
}
let mut writes = Vec::new();
for node_ref in get_topological(self.block) {
match &self.block.get_node(node_ref).payload {
NodePayload::Nil
| NodePayload::InputPort { .. }
| NodePayload::OutputPort { .. } => {
}
NodePayload::RegisterRead { register } => {
if let Some(signal) = self.register_refs.get(register).copied() {
self.values[node_ref.index] =
Some(Value::signal(signal).with_type(self.block.get_node_ty(node_ref)));
}
}
NodePayload::RegisterWrite { .. } => writes.push(node_ref),
_ => self.emit_node(node_ref)?,
}
}
self.emit_register_groups(&writes)?;
self.file.hoist_module_declarations(self.module, start);
Ok(())
}
fn emit_pipeline(&mut self) -> Result<(), BlockCodegenError> {
let layout = reconstruct_stages(self.package, self.block)?;
let mut emitted_visible_stage = false;
for (stage_index, stage) in layout.stages.iter().enumerate() {
self.current_stage = Some(stage_index);
let visible =
!stage.combinational_nodes.is_empty() || !stage.register_writes.is_empty();
if visible {
if emitted_visible_stage {
let blank = self.file.make_blank_line();
self.file.add_member_blank_line(self.module, blank);
}
let comment = self
.file
.make_comment(&format!("===== Pipe stage {stage_index}:"));
self.file.add_member_comment(self.module, comment);
emitted_visible_stage = true;
}
self.emit_stage(stage, stage_index)?;
}
self.current_stage = None;
Ok(())
}
fn emit_stage(&mut self, stage: &Stage, stage_index: usize) -> Result<(), BlockCodegenError> {
for &node_ref in &stage.register_reads {
if let NodePayload::RegisterRead { register } = &self.block.get_node(node_ref).payload {
if let Some(signal) = self.register_refs.get(register).copied() {
self.values[node_ref.index] =
Some(Value::signal(signal).with_type(self.block.get_node_ty(node_ref)));
}
}
}
let start = self.file.module_member_count(self.module);
if stage_index == 0 {
self.emit_input_array_views()?;
}
for &node_ref in &stage.combinational_nodes {
self.emit_node(node_ref)?;
}
self.file.hoist_module_declarations(self.module, start);
if !stage.register_writes.is_empty() {
let blank = self.file.make_blank_line();
self.file.add_member_blank_line(self.module, blank);
let comment = self
.file
.make_comment(&format!("Registers for pipe stage {stage_index}:"));
self.file.add_member_comment(self.module, comment);
for &node_ref in &stage.register_writes {
if let NodePayload::RegisterWrite { register, .. } =
&self.block.get_node(node_ref).payload
{
let definition = self
.block
.registers
.iter()
.find(|definition| definition.name == *register)
.ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"register `{register}` has no declaration in block `{}`",
self.block.name
))
})?;
self.declare_register(definition)?;
}
}
self.emit_register_groups(&stage.register_writes)?;
}
Ok(())
}
fn declare_register(&mut self, register: &Register) -> Result<(), BlockCodegenError> {
if register.ty.bit_count() == 0 || self.register_refs.contains_key(®ister.name) {
return Ok(());
}
let data_type = self.value_type(®ister.ty);
let name = self.unique_name(®ister.name);
let signal = self.file.add_logic(self.module, &name, &data_type)?;
self.register_refs.insert(register.name.clone(), signal);
Ok(())
}
fn emit_register_groups(&mut self, writes: &[NodeRef]) -> Result<(), BlockCodegenError> {
let mut resettable = Vec::new();
let mut ordinary = Vec::new();
for &node_ref in writes {
let NodePayload::RegisterWrite {
arg,
register,
load_enable,
reset,
} = &self.block.get_node(node_ref).payload
else {
continue;
};
let Some(&signal) = self.register_refs.get(register) else {
continue;
};
let definition = self
.block
.registers
.iter()
.find(|definition| definition.name == *register)
.expect("verified register write has a declaration");
let next = self.required_value(*arg)?.expr;
let enable = load_enable
.map(|node| self.required_value(node).map(|value| value.expr))
.transpose()?;
let reset_signal = reset
.map(|node| self.required_value(node).map(|value| value.expr))
.transpose()?;
let reset_value = if reset_signal.is_some() {
definition
.reset_value
.as_ref()
.map(|value| self.literal(value, &definition.ty))
.transpose()?
.flatten()
} else {
None
};
let register = RegisterDefinition {
reg: signal.to_expr(),
next,
reset_value,
enable,
};
if let Some(signal) = reset_signal {
resettable.push((signal, register));
} else {
ordinary.push(register);
}
}
if ordinary.is_empty() && resettable.is_empty() {
return Ok(());
}
let clock_name = self.block.clock_port_name().ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"block `{}` has registers but no clock port",
self.block.name
))
})?;
let clock = self
.ports
.get(clock_name)
.ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"block `{}` has no declared clock port `{clock_name}`",
self.block.name
))
})?
.to_expr();
if !ordinary.is_empty() {
xlsynth::vast_helpers::add_registers(
&clock,
None,
&ordinary,
RegisterScope::Module(self.module),
self.file,
self.options.register_codegen_options.as_ref(),
)?;
}
if !resettable.is_empty() {
let reset_metadata = self.block.reset.as_ref().ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"block `{}` has resettable registers but no reset metadata",
self.block.name
))
})?;
let mut groups = Vec::<ResettableRegisterGroup>::new();
for (signal, register) in resettable {
if let Some(group) = groups.iter_mut().find(|group| group.signal == signal) {
group.registers.push(register);
} else {
groups.push(ResettableRegisterGroup {
signal,
registers: vec![register],
});
}
}
for group in groups {
let reset = Reset {
signal: group.signal,
active_low: reset_metadata.active_low,
};
if reset_metadata.asynchronous {
if let Some(options) = &self.options.register_codegen_options {
let requires_enable = group
.registers
.iter()
.any(|register| register.enable.is_some());
if options.reg_with_reset_template.is_some()
|| (requires_enable
&& options.reg_with_reset_with_en_template.is_some())
{
return Err(BlockCodegenError::Unsupported(format!(
concat!(
"block `{}` has asynchronous reset; custom reset-register ",
"templates cannot guarantee the required reset edge semantics"
),
self.block.name
)));
}
}
self.emit_asynchronous_registers(&clock, reset, &group.registers)?;
} else {
xlsynth::vast_helpers::add_registers(
&clock,
Some(reset),
&group.registers,
RegisterScope::Module(self.module),
self.file,
self.options.register_codegen_options.as_ref(),
)?;
}
}
}
Ok(())
}
fn emit_asynchronous_registers(
&mut self,
clock: &Expr,
reset: Reset,
registers: &[RegisterDefinition],
) -> Result<(), BlockCodegenError> {
let clock_edge = self.file.make_pos_edge(clock);
let reset_edge = if reset.active_low {
self.file.make_neg_edge(&reset.signal)
} else {
self.file.make_pos_edge(&reset.signal)
};
let always = self
.file
.add_always_ff(self.module, &[&clock_edge, &reset_edge])?;
let body = self.file.statement_block(always);
let condition = if reset.active_low {
self.file.make_logical_not(&reset.signal)
} else {
reset.signal
};
let conditional = self.file.block_add_cond(body, &condition);
let reset_body = self.file.conditional_then_block(conditional);
let update_body = self.file.conditional_add_else(conditional);
for register in registers {
let reset_value = register
.reset_value
.expect("resettable register group requires reset values");
self.file
.block_add_nonblocking_assignment(reset_body, ®ister.reg, &reset_value);
let next = if let Some(enable) = register.enable {
self.file
.make_ternary(&enable, ®ister.next, ®ister.reg)
} else {
register.next
};
self.file
.block_add_nonblocking_assignment(update_body, ®ister.reg, &next);
}
Ok(())
}
fn emit_outputs(&mut self) -> Result<(), BlockCodegenError> {
for port in self.block.output_ports() {
let name = self.block.port_name(port);
let node_ref = self.block.output_value(port);
let Some(signal) = self.ports.get(name).copied() else {
continue;
};
let value = self.required_value(node_ref)?;
let assignment = self
.file
.make_continuous_assignment(&signal.to_expr(), &value.expr);
self.file
.add_member_continuous_assignment(self.module, assignment);
}
Ok(())
}
fn emit_instantiations(&mut self) -> Result<(), BlockCodegenError> {
if self.block.instantiations.is_empty() {
return Ok(());
}
if self.options.layout == Layout::Pipeline {
let blank = self.file.make_blank_line();
self.file.add_member_blank_line(self.module, blank);
let comment = self.file.make_comment("===== Instantiations");
self.file.add_member_comment(self.module, comment);
}
for instance in &self.block.instantiations {
validate_external_identifier(&instance.name, "instance")?;
let mut connections = self
.instance_inputs
.iter()
.chain(self.instance_outputs.iter())
.filter(|((name, _), _)| name == &instance.name)
.map(|((_, port), expr)| (port.clone(), *expr))
.collect::<Vec<_>>();
if instance.kind == InstantiationKind::Block {
let child = self
.package
.members
.iter()
.find_map(|member| match member {
PackageMember::Block(block) if block.name == instance.block => Some(block),
_ => None,
})
.expect("validated child block exists");
if let Some(clock_name) = child.clock_port_name() {
if !connections.iter().any(|(name, _)| name == clock_name) {
if let Some(parent_clock) = self
.block
.clock_port_name()
.and_then(|name| self.ports.get(name))
{
connections.push((clock_name.to_string(), parent_clock.to_expr()));
} else {
return Err(BlockCodegenError::InvalidBlock(format!(
"instance `{}` of block `{}` requires clock port \
`{clock_name}`, but parent block `{}` has no clock",
instance.name, instance.block, self.block.name
)));
}
}
}
let order = child
.ports
.iter()
.map(|port| match port {
BlockPort::Clock(name) => name.as_str(),
BlockPort::Input(node) | BlockPort::Output(node) => child.port_name(*node),
})
.collect::<Vec<_>>();
connections.sort_by_key(|(name, _)| {
(
order
.iter()
.position(|port| *port == name)
.unwrap_or(usize::MAX),
name.clone(),
)
});
let names = connections
.iter()
.map(|(name, _)| name.as_str())
.collect::<Vec<_>>();
let expressions = connections
.iter()
.map(|(_, expr)| Some(expr))
.collect::<Vec<_>>();
let handle = self.file.make_instantiation(
&instance.block,
&instance.name,
&[],
&[],
&names,
&expressions,
);
self.file.add_member_instantiation(self.module, handle);
} else {
self.emit_external_instantiation(instance, &connections)?;
}
}
Ok(())
}
fn emit_external_instantiation(
&mut self,
instance: &xlsynth_pir::ir::Instantiation,
connections: &[(String, Expr)],
) -> Result<(), BlockCodegenError> {
let foreign = self.package.get_fn(&instance.block).ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"external instance `{}` references missing function `{}`",
instance.name, instance.block
))
})?;
let attribute = foreign
.outer_attrs
.iter()
.find(|attribute| attribute.contains("code_template:"))
.ok_or_else(|| {
BlockCodegenError::Unsupported(format!(
"external function `{}` has no ffi_proto code_template",
foreign.name
))
})?;
let marker = attribute.find("code_template:").expect("template marker");
let remainder = attribute[marker + "code_template:".len()..].trim_start();
let start = remainder.find('"').ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"external function `{}` has an invalid ffi_proto code_template",
foreign.name
))
})?;
let mut escaped = false;
let mut end = None;
for (index, character) in remainder[start + 1..].char_indices() {
if escaped {
escaped = false;
} else if character == '\\' {
escaped = true;
} else if character == '"' {
end = Some(start + 1 + index);
break;
}
}
let end = end.ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"external function `{}` has an unterminated ffi_proto code_template",
foreign.name
))
})?;
let template = remainder[start + 1..end]
.replace("\\n", "\n")
.replace("\\\"", "\"")
.replace("\\\\", "\\");
let bindings = connections
.iter()
.map(|(name, value)| (name.as_str(), self.file.emit_expression(value)))
.collect::<BTreeMap<_, _>>();
let template = substitute_external_template(&template, &instance.name, &bindings)?;
let statement = self.file.make_inline_verilog_statement(template.trim());
self.file
.add_member_inline_statement(self.module, statement);
Ok(())
}
pub(crate) fn bits_type(&mut self, width: usize) -> VastDataType {
self.file.make_bit_vector_type(width as i64, false)
}
pub(crate) fn value_type(&mut self, mut ty: &Type) -> VastDataType {
let mut dimensions = Vec::new();
while let Type::Array(array) = ty {
dimensions.push(array.element_count as i64);
ty = &array.element_type;
}
let element = self.bits_type(ty.bit_count());
if dimensions.is_empty() {
element
} else {
self.file.make_packed_array_type(element, &dimensions)
}
}
fn emit_input_array_views(&mut self) -> Result<(), BlockCodegenError> {
for (index, node) in self.block.nodes.iter().enumerate() {
if matches!(node.payload, NodePayload::InputPort { .. })
&& matches!(node.ty, Type::Array(_))
&& let Some(value) = self.values[index]
&& value.array_rank == 0
{
let view = self.assign_node(NodeRef { index }, value.expr)?;
self.values[index] = Some(view);
}
}
Ok(())
}
pub(crate) fn required_value(&self, node: NodeRef) -> Result<Value, BlockCodegenError> {
self.values[node.index].ok_or_else(|| {
BlockCodegenError::InvalidBlock(format!(
"node `{}` in block `{}` has no representable SystemVerilog value",
self.block.get_node(node).name.clone().unwrap_or_else(|| {
format!(
"{}.{}",
self.block.get_node(node).payload.get_operator(),
self.block.get_node(node).text_id
)
}),
self.block.name
))
})
}
pub(crate) fn literal(
&mut self,
value: &IrValue,
ty: &Type,
) -> Result<Option<Expr>, BlockCodegenError> {
if ty.bit_count() == 0 {
return Ok(None);
}
match ty {
Type::Bits(_) => {
let formatted = value.to_string_fmt(IrFormatPreference::Hex);
Ok(Some(
self.file.make_literal(&formatted, &LiteralFormat::Hex)?,
))
}
Type::Tuple(types) => {
let values = value.as_elements()?;
let mut expressions = Vec::new();
for (value, ty) in values.iter().zip(types) {
if let Some(expression) = self.literal(value, ty)? {
expressions.push(expression);
}
}
Ok(self.concat_or_only(&expressions))
}
Type::Array(array) => {
let values = value.as_elements()?;
let mut expressions = Vec::new();
for value in values.iter().rev() {
if let Some(expression) = self.literal(value, &array.element_type)? {
expressions.push(expression);
}
}
Ok(self.concat_or_only(&expressions))
}
Type::Token => Ok(None),
}
}
pub(crate) fn concat_or_only(&mut self, expressions: &[Expr]) -> Option<Expr> {
match expressions {
[] => None,
[only] => Some(*only),
many => {
let refs = many.iter().collect::<Vec<_>>();
Some(self.file.make_concat(&refs))
}
}
}
pub(crate) fn unique_name(&mut self, requested: &str) -> String {
let mut base = sanitize_identifier(requested);
if self.names.insert(base.clone()) {
return base;
}
let mut index = 1usize;
loop {
let candidate = format!("{base}__{index}");
if self.names.insert(candidate.clone()) {
return candidate;
}
index += 1;
if index == usize::MAX {
base.push('_');
index = 1;
}
}
}
pub(crate) fn declare_node(
&mut self,
node_ref: NodeRef,
) -> Result<LogicRef, BlockCodegenError> {
let name = self.node_name(node_ref);
let unique = self.unique_name(&name);
let ty = self.value_type(self.block.get_node_ty(node_ref));
Ok(self.file.add_logic(self.module, &unique, &ty)?)
}
pub(crate) fn node_name(&self, node_ref: NodeRef) -> String {
let node = self.block.get_node(node_ref);
let original_name = node
.name
.clone()
.unwrap_or_else(|| format!("{}_{}", node.payload.get_operator(), node.text_id));
if let Some(stage) = self.current_stage {
let base = strip_pipeline_prefix(&original_name);
format!("p{stage}_{base}_comb")
} else {
original_name
}
}
pub(crate) fn assign_node(
&mut self,
node_ref: NodeRef,
expression: Expr,
) -> Result<Value, BlockCodegenError> {
let signal = self.declare_node(node_ref)?;
let assignment = self
.file
.make_continuous_assignment(&signal.to_expr(), &expression);
self.file
.add_member_continuous_assignment(self.module, assignment);
Ok(Value::signal(signal).with_type(self.block.get_node_ty(node_ref)))
}
pub(crate) fn should_assign(&self, node_ref: NodeRef, depth: usize) -> bool {
self.must_assign(node_ref)
|| self.block.get_node(node_ref).name.is_some()
|| self.users[node_ref.index].len() > 1
|| depth > self.options.max_inline_depth
}
fn must_assign(&self, node_ref: NodeRef) -> bool {
let node = self.block.get_node(node_ref);
matches!(node.ty, Type::Array(_))
|| matches!(
node.payload,
NodePayload::ArrayIndex { .. }
| NodePayload::ExtCarryOut { .. }
| NodePayload::ExtNaryAdd { .. }
)
|| matches!(
node.payload,
NodePayload::Binop(
Binop::Add
| Binop::Sub
| Binop::Smul
| Binop::Umul
| Binop::Smulp
| Binop::Umulp
| Binop::Sdiv
| Binop::Udiv,
_,
_
)
)
|| self.options.separate_lines
|| self.users[node_ref.index]
.iter()
.any(|user| self.operand_must_be_named_reference(*user, node_ref))
}
fn operand_must_be_named_reference(&self, user: NodeRef, operand: NodeRef) -> bool {
match &self.block.get_node(user).payload {
NodePayload::RegisterWrite { .. } => true,
NodePayload::BitSlice { arg, .. } => *arg == operand,
NodePayload::TupleIndex { tuple, .. } => *tuple == operand,
NodePayload::SignExt { arg, .. } => {
*arg == operand && self.block.get_node_ty(operand).bit_count() > 1
}
NodePayload::ExtNaryAdd { terms, .. } => {
terms.iter().any(|term| term.operand == operand)
}
NodePayload::OneHot { arg, .. }
| NodePayload::Encode { arg }
| NodePayload::ExtPrioEncode { arg, .. }
| NodePayload::ExtClz { arg, .. }
| NodePayload::ExtNormalizeLeft { arg, .. }
| NodePayload::Unop(Unop::Reverse, arg) => {
*arg == operand && self.block.get_node_ty(operand).bit_count() > 1
}
NodePayload::Sel {
selector, cases, ..
}
| NodePayload::PrioritySel {
selector, cases, ..
}
| NodePayload::OneHotSel { selector, cases } => *selector == operand && cases.len() > 1,
NodePayload::ArraySlice {
array,
start,
width,
} => *width > 1 && (*array == operand || *start == operand),
NodePayload::ArrayUpdate { indices, .. } => {
indices.contains(&operand)
}
_ => false,
}
}
}
fn substitute_external_template(
template: &str,
instance_name: &str,
bindings: &BTreeMap<&str, String>,
) -> Result<String, BlockCodegenError> {
let bytes = template.as_bytes();
let mut output = String::with_capacity(template.len());
let mut index = 0usize;
while index < bytes.len() {
match bytes[index] {
b'{' if bytes.get(index + 1) == Some(&b'{') => {
output.push('{');
index += 2;
}
b'}' if bytes.get(index + 1) == Some(&b'}') => {
output.push('}');
index += 2;
}
b'{' => {
let start = index + 1;
let mut nesting = 1usize;
index = start;
while index < bytes.len() && nesting != 0 {
match bytes[index] {
b'{' => nesting += 1,
b'}' => nesting -= 1,
_ => {
}
}
if nesting != 0 {
index += 1;
}
}
if index >= bytes.len() {
return Err(BlockCodegenError::InvalidBlock(format!(
"external instance `{instance_name}` has an unterminated \
ffi_proto placeholder"
)));
}
let name = &template[start..index];
if name == "fn" {
output.push_str(instance_name);
} else if let Some(value) = bindings.get(name) {
output.push_str(value);
} else {
return Err(BlockCodegenError::InvalidBlock(format!(
"external instance `{instance_name}` leaves ffi_proto \
placeholder `{{{name}}}` unresolved"
)));
}
index += 1;
}
b'}' => {
return Err(BlockCodegenError::InvalidBlock(format!(
"external instance `{instance_name}` has an unmatched \
closing brace in its ffi_proto template"
)));
}
_ => {
let character = template[index..]
.chars()
.next()
.expect("byte index is positioned at a UTF-8 character");
output.push(character);
index += character.len_utf8();
}
}
}
Ok(output)
}
pub(crate) fn validate_external_identifier(
name: &str,
kind: &str,
) -> Result<(), BlockCodegenError> {
if sanitize_identifier(name) != name {
return Err(BlockCodegenError::InvalidBlock(format!(
"invalid SystemVerilog {kind} identifier `{name}`: identifier is reserved, \
malformed, or requires escaping"
)));
}
Ok(())
}
fn sanitize_identifier(name: &str) -> String {
let mut output = String::with_capacity(name.len() + 1);
for (index, character) in name.chars().enumerate() {
if character.is_ascii_alphabetic()
|| character == '_'
|| (index != 0 && (character.is_ascii_digit() || character == '$'))
{
output.push(character);
} else {
if index == 0 && character.is_ascii_digit() {
output.push('_');
output.push(character);
} else {
output.push('_');
}
}
}
if output.is_empty() {
output.push('_');
}
if xlsynth_vast::is_system_verilog_keyword(&output) {
output.push('_');
}
output
}
fn strip_pipeline_prefix(name: &str) -> &str {
let Some(rest) = name.strip_prefix('p') else {
return name;
};
let digit_count = rest.chars().take_while(char::is_ascii_digit).count();
if digit_count > 0 && rest[digit_count..].starts_with('_') {
&rest[digit_count + 1..]
} else {
name
}
}