From 01e15ce040ef689afcecefcb7910855d0b2dcc0e Mon Sep 17 00:00:00 2001 From: Guojie Luo Date: Sun, 24 Apr 2022 09:29:53 +0800 Subject: [PATCH] Add struct SyntaxTable --- src/bin/sv-to-llhd.rs | 23 +++++++++++++++- src/cst/always_statement.rs | 4 +-- src/cst/case_statement.rs | 4 +-- src/cst/conditional_statement.rs | 4 +-- src/cst/context.rs | 23 +++++++++++++--- src/cst/description_list.rs | 6 ++--- src/cst/expression.rs | 29 +++++++++++++++------ src/cst/mod.rs | 2 +- src/cst/module_declaration.rs | 18 ++++++++----- src/cst/net_variable_assignment.rs | 2 +- src/cst/nonblocking_assignment_statement.rs | 2 +- src/cst/seq_block.rs | 2 +- src/cst/statement.rs | 2 +- 13 files changed, 88 insertions(+), 33 deletions(-) diff --git a/src/bin/sv-to-llhd.rs b/src/bin/sv-to-llhd.rs index b61ec4b..6969fc0 100644 --- a/src/bin/sv-to-llhd.rs +++ b/src/bin/sv-to-llhd.rs @@ -10,6 +10,9 @@ use std::{ result::Result, }; +#[allow(unused_imports)] +use log::{debug, error, info, trace, warn}; + fn main() { match main_inner() { Ok(_) => (), @@ -82,7 +85,25 @@ fn main_inner() -> Result<(), std::io::Error> { let module_list = DescriptionList::codegen(json_tree); - for (mut module, _json_module) in module_list { + for (mut module, syntax_table) in module_list { + for proc in module.processes() { + for inst in proc.all_insts() { + let v = proc.get_inst_result(inst); + let json = if v.is_some() { + syntax_table.values.get(&v.unwrap()) + } else { + None + }; + if json.is_some() { + trace!( + r#"inst "{}" from syntax node {}"#, + inst.dump(&proc), + json.unwrap() + ); + } + } + } + let pass_ctx = PassContext; llhd::pass::GlobalCommonSubexprElim::run_on_module(&pass_ctx, &mut module); //llhd::pass::InstSimplification::run_on_module(&pass_ctx, &mut module); diff --git a/src/cst/always_statement.rs b/src/cst/always_statement.rs index ebace6d..d8f004f 100644 --- a/src/cst/always_statement.rs +++ b/src/cst/always_statement.rs @@ -12,7 +12,7 @@ use log::{debug, error, info, trace, warn}; pub struct AlwaysStatement {} impl AlwaysStatement { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { match json["children"][0]["tag"].as_str() { Some(Tag::ALWAYS) => Some(Self::gen_always(json, context)), Some(Tag::ALWAYS_COMB) => { @@ -25,7 +25,7 @@ impl AlwaysStatement { } } - fn gen_always(json: &JsonValue, context: &mut ModuleContext) -> UnitId { + fn gen_always<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> UnitId { let (json_event_expression_list, json_statement) = { let json_always = Tools::match_tags( vec![json], diff --git a/src/cst/case_statement.rs b/src/cst/case_statement.rs index 402aa8b..4eb03c3 100644 --- a/src/cst/case_statement.rs +++ b/src/cst/case_statement.rs @@ -8,7 +8,7 @@ use log::{debug, error, info, trace, warn}; pub struct CaseStatement {} impl CaseStatement { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let (json_expression, json_case_items, json_default_statement) = Self::analyze(json); if context.unit_ctx.data.is_none() { @@ -119,7 +119,7 @@ impl CaseStatement { Some(bb_last) } - fn visit_case_body(json: &JsonValue, context: &mut ModuleContext) -> Option { + fn visit_case_body<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let stmt = Statement::codegen(json, context); if context.unit_ctx.data.is_some() { diff --git a/src/cst/conditional_statement.rs b/src/cst/conditional_statement.rs index 7a47ebd..330cfdc 100644 --- a/src/cst/conditional_statement.rs +++ b/src/cst/conditional_statement.rs @@ -8,7 +8,7 @@ use log::{debug, error, info, trace, warn}; pub struct ConditionalStatement {} impl ConditionalStatement { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let (json_if_header, json_if_body, json_else_body) = Self::analyze(json); if context.unit_ctx.data.is_none() { @@ -125,7 +125,7 @@ impl ConditionalStatement { } } - fn visit_ite_body(json: &JsonValue, context: &mut ModuleContext) -> Option { + fn visit_ite_body<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let json_child = &json["children"]; assert_eq!(json_child.len(), 1); let stmt = Statement::codegen(&json_child[0], context); diff --git a/src/cst/context.rs b/src/cst/context.rs index 6bc0c8d..754a334 100644 --- a/src/cst/context.rs +++ b/src/cst/context.rs @@ -1,3 +1,4 @@ +use json::JsonValue; use linked_hash_map::LinkedHashMap; use linked_hash_set::LinkedHashSet; use llhd::{ @@ -7,11 +8,12 @@ use llhd::{ }; use std::{collections::HashMap, fmt}; -pub struct ModuleContext { +pub struct ModuleContext<'a> { pub name: String, pub module: Module, pub symbol: LinkedHashMap, pub unit_ctx: UnitContext, + pub syntax_table: SyntaxTable<'a>, } pub struct UnitContext { @@ -27,6 +29,11 @@ pub struct UnitContext { pub ty_active: Option, } +pub struct SyntaxTable<'a> { + pub root: &'a JsonValue, + pub values: HashMap, +} + pub struct SymbolInfo { pub kind: SymbolKind, pub value: IntValue, @@ -53,13 +60,14 @@ impl fmt::Display for SymbolKind { } } -impl ModuleContext { - pub fn new() -> Self { +impl<'a> ModuleContext<'a> { + pub fn new(json: &'a JsonValue) -> Self { Self { name: String::new(), module: Module::new(), symbol: LinkedHashMap::new(), unit_ctx: UnitContext::new(), + syntax_table: SyntaxTable::new(json), } } } @@ -125,6 +133,15 @@ impl UnitContext { } } +impl<'a> SyntaxTable<'a> { + pub fn new(json: &'a JsonValue) -> Self { + Self { + root: json, + values: HashMap::new(), + } + } +} + impl SymbolInfo { pub fn new(kind: SymbolKind, value: IntValue) -> Self { Self { diff --git a/src/cst/description_list.rs b/src/cst/description_list.rs index 8758e89..a988cc2 100644 --- a/src/cst/description_list.rs +++ b/src/cst/description_list.rs @@ -1,17 +1,17 @@ -use crate::cst::{ModuleDeclaration, Tag, Tools}; +use crate::cst::{ModuleDeclaration, SyntaxTable, Tag, Tools}; use json::JsonValue; use llhd::ir::Module; pub struct DescriptionList {} impl DescriptionList { - pub fn codegen(json: &JsonValue) -> Vec<(Module, &JsonValue)> { + pub fn codegen(json: &JsonValue) -> Vec<(Module, SyntaxTable)> { Tools::match_tags( vec![json], vec![Tag::DESCRIPTION_LIST, Tag::MODULE_DECLARATION], ) .iter() - .map(|&x| (ModuleDeclaration::codegen(x), x)) + .map(|&x| ModuleDeclaration::codegen(x)) .collect() } } diff --git a/src/cst/expression.rs b/src/cst/expression.rs index b90bb01..d23f917 100644 --- a/src/cst/expression.rs +++ b/src/cst/expression.rs @@ -15,7 +15,7 @@ impl Expression { Self::gen_reference_call(json, context).0 } - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { match json["tag"].as_str() { Some(Tag::EXPRESSION) => { let json_expr = &json["children"]; @@ -138,7 +138,10 @@ impl Expression { } } - fn gen_binary_expression(json: &JsonValue, context: &mut ModuleContext) -> Option { + fn gen_binary_expression<'a>( + json: &'a JsonValue, + context: &mut ModuleContext<'a>, + ) -> Option { let json_children = &json["children"]; assert_eq!(json_children.len(), 3); let operand_l = Self::codegen(&json_children[0], context); @@ -157,7 +160,7 @@ impl Expression { let opd_l = operand_l.unwrap(); let opd_r = operand_r.unwrap(); - match json_children[1]["tag"].as_str() { + let value = match json_children[1]["tag"].as_str() { Some("+") => { let value = builder.ins().add(opd_l, opd_r); Some(value) @@ -202,13 +205,20 @@ impl Expression { None } _ => panic!("unknown error at CST node '{}'", json), + }; + if value.is_some() { + context.syntax_table.values.insert(value.unwrap(), json); } + value } else { None } } - fn gen_unary_prefix_expression(json: &JsonValue, context: &mut ModuleContext) -> Option { + fn gen_unary_prefix_expression<'a>( + json: &'a JsonValue, + context: &mut ModuleContext<'a>, + ) -> Option { let json_children = &json["children"]; assert_eq!(json_children.len(), 2); let expr = Self::codegen(&json_children[1], context); @@ -244,9 +254,9 @@ impl Expression { } } - fn gen_concatenation_expression( - json: &JsonValue, - context: &mut ModuleContext, + fn gen_concatenation_expression<'a>( + json: &'a JsonValue, + context: &mut ModuleContext<'a>, ) -> Option { let json_expressions = Tools::match_tags( vec![json], @@ -294,7 +304,10 @@ impl Expression { } } - fn gen_conditional_expression(json: &JsonValue, context: &mut ModuleContext) -> Option { + fn gen_conditional_expression<'a>( + json: &'a JsonValue, + context: &mut ModuleContext<'a>, + ) -> Option { let json_children = &json["children"]; assert_eq!(json_children.len(), 5); diff --git a/src/cst/mod.rs b/src/cst/mod.rs index fd43d53..8d9a593 100644 --- a/src/cst/mod.rs +++ b/src/cst/mod.rs @@ -17,7 +17,7 @@ mod tools; use always_statement::AlwaysStatement; use case_statement::CaseStatement; use conditional_statement::ConditionalStatement; -use context::{ModuleContext, SymbolInfo, SymbolKind, UnitContext}; +use context::{ModuleContext, SymbolInfo, SymbolKind, SyntaxTable, UnitContext}; use expression::Expression; use module_declaration::ModuleDeclaration; use net_variable_assignment::NetVariableAssignment; diff --git a/src/cst/module_declaration.rs b/src/cst/module_declaration.rs index 489481d..920fb56 100644 --- a/src/cst/module_declaration.rs +++ b/src/cst/module_declaration.rs @@ -1,6 +1,6 @@ use crate::cst::{ - AlwaysStatement, ModuleContext, NetVariableAssignment, SymbolDeclaration, SymbolKind, Tag, - Tools, UnitContext, + AlwaysStatement, ModuleContext, NetVariableAssignment, SymbolDeclaration, SymbolKind, + SyntaxTable, Tag, Tools, UnitContext, }; use json::JsonValue; use llhd::{ @@ -15,8 +15,8 @@ use log::{debug, error, info, trace, warn}; pub struct ModuleDeclaration {} impl ModuleDeclaration { - pub fn codegen(json: &JsonValue) -> Module { - let mut context = ModuleContext::new(); + pub fn codegen(json: &JsonValue) -> (Module, SyntaxTable) { + let mut context = ModuleContext::new(json); SymbolDeclaration::declare_port(json, &mut context); SymbolDeclaration::declare_reg(json, &mut context); @@ -41,7 +41,7 @@ impl ModuleDeclaration { context.module.dump() ); - context.module + (context.module, context.syntax_table) } fn gen_entity_data(json: &JsonValue, context: &mut ModuleContext) { @@ -131,7 +131,7 @@ impl ModuleDeclaration { } } - fn gen_assignment(json: &JsonValue, context: &mut ModuleContext) { + fn gen_assignment<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) { let json_wire_assignments = &Tools::match_tags( vec![json], vec![ @@ -153,7 +153,11 @@ impl ModuleDeclaration { context.unit_ctx.bb_head.pop(); } - fn gen_always(json: &JsonValue, entity_ctx: &mut UnitContext, context: &mut ModuleContext) { + fn gen_always<'a>( + json: &'a JsonValue, + entity_ctx: &mut UnitContext, + context: &mut ModuleContext<'a>, + ) { let json_always_statements = &Tools::match_tags( vec![json], vec![ diff --git a/src/cst/net_variable_assignment.rs b/src/cst/net_variable_assignment.rs index 1c4a36f..8e7401e 100644 --- a/src/cst/net_variable_assignment.rs +++ b/src/cst/net_variable_assignment.rs @@ -11,7 +11,7 @@ use log::{debug, error, info, trace, warn}; pub struct NetVariableAssignment {} impl NetVariableAssignment { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let (json_lpvalue, json_expression) = { assert_eq!(json["tag"], Tag::NET_VARIABLE_ASSIGNMENT); diff --git a/src/cst/nonblocking_assignment_statement.rs b/src/cst/nonblocking_assignment_statement.rs index 96c8b20..02e18ad 100644 --- a/src/cst/nonblocking_assignment_statement.rs +++ b/src/cst/nonblocking_assignment_statement.rs @@ -8,7 +8,7 @@ use log::{debug, error, info, trace, warn}; pub struct NonblockingAssignmentStatement {} impl NonblockingAssignmentStatement { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let (json_lpvalue, json_expression) = { assert_eq!(json["tag"], Tag::NONBLOCKING_ASSIGNMENT_STATEMENT); diff --git a/src/cst/seq_block.rs b/src/cst/seq_block.rs index 26313cd..65328de 100644 --- a/src/cst/seq_block.rs +++ b/src/cst/seq_block.rs @@ -5,7 +5,7 @@ use llhd::ir::Block; pub struct SeqBlock {} impl SeqBlock { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { let json_block_item_statement_list = { let json_vec = Tools::match_tags( vec![json], diff --git a/src/cst/statement.rs b/src/cst/statement.rs index 289d3c0..e34bc76 100644 --- a/src/cst/statement.rs +++ b/src/cst/statement.rs @@ -11,7 +11,7 @@ use log::{debug, error, info, trace, warn}; pub struct Statement {} impl Statement { - pub fn codegen(json: &JsonValue, context: &mut ModuleContext) -> Option { + pub fn codegen<'a>(json: &'a JsonValue, context: &mut ModuleContext<'a>) -> Option { match json["tag"].as_str() { Some(Tag::SEQ_BLOCK) => SeqBlock::codegen(json, context), Some(Tag::CONDITIONAL_STATEMENT) => ConditionalStatement::codegen(json, context),