dasys
/
cst-to-llhd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove unnecessary set_name() for values

This commit is contained in:
Guojie Luo 2022-03-20 14:03:36 +08:00
parent e70336f2ec
commit b496ac1eb4
4 changed files with 59 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/bin/x-lint.rs
View File

@ -121,7 +121,8 @@ fn main_inner() -> Result<(), std::io::Error> {
println!("");
}
}
println!("{}", module.dump());
llhd::assembly::write_module(std::io::stdout(), &module);
}
Ok(())

77
src/cst/always_statement.rs
View File

@ -1,7 +1,7 @@
use crate::cst::{Expression, ModuleContext, Statement, SymbolKind, Tag, Tools, UnitContext};
use json::JsonValue;
use llhd::{
ir::{Block, Opcode, Signature, UnitId, UnitKind, UnitName, Value},
ir::{Block, Inst, Opcode, Signature, UnitId, UnitKind, UnitName, Value},
ty::{int_ty, signal_ty, Type},
value::TimeValue,
};
@ -129,9 +129,14 @@ impl AlwaysStatement {
builder.ins().br(bb_first);
// remove blocks with a single jump
let blocks: Vec<Block> = builder.unit().blocks().collect();
for block in blocks {
if builder.unit().insts(block).count() == 1 {
// to-do: consider using dead-code-elimination in llhd
{
let single_inst_blocks: Vec<Block> = builder
.unit()
.blocks()
.filter(|&x| builder.unit().insts(x).count() == 1)
.collect();
for block in single_inst_blocks {
let inst = builder.unit().insts(block).last().unwrap();
let inst_data = &builder[inst];
if inst_data.opcode() == Opcode::Br {
@ -143,9 +148,42 @@ impl AlwaysStatement {
}
}
// name unamed values
for (i, &value) in unit_ctx.unamed_values.iter().enumerate() {
builder.set_name(value, format!("{}", i + 1));
// name values for 'prb' and 'ld' instructions
{
let mut prb_count = HashMap::<String, usize>::new();
let mut ld_count = HashMap::<String, usize>::new();
let get_name = |base_name: &String, count: &mut HashMap<String, usize>| -> String {
if count.contains_key(base_name) {
count.insert(base_name.clone(), count[base_name] + 1);
format!("{}{}", base_name, count[base_name])
} else {
count.insert(base_name.clone(), 0);
base_name.clone()
}
};
let insts: Vec<Inst> = builder.unit().all_insts().collect();
for inst in insts {
let inst_data = &builder[inst];
let output = builder.get_inst_result(inst);
match inst_data.opcode() {
Opcode::Prb => {
let input = inst_data.args()[0];
let input_name = builder.unit().get_name(input).unwrap();
let skip = unit_ctx.raw_name_to_shadow.contains_key(input_name);
if !skip {
// skip shadows
let base_name = &format!("{}.prb", input_name);
builder.set_name(output.unwrap(), get_name(base_name, &mut prb_count));
}
}
Opcode::Ld => {
let input = inst_data.args()[0];
let base_name = &format!("{}.ld", builder.unit().get_name(input).unwrap());
builder.set_name(output.unwrap(), get_name(base_name, &mut ld_count));
}
_ => {}
}
}
}
}
@ -183,7 +221,6 @@ impl AlwaysStatement {
if context.unit_ctx.data.is_some() {
let unit_ctx = &mut context.unit_ctx;
let unamed_values = &mut unit_ctx.unamed_values;
let raw_name_to_value = &mut unit_ctx.raw_name_to_value;
let raw_name_to_shadow = &mut unit_ctx.raw_name_to_shadow;
let raw_name_to_arg = &unit_ctx.raw_name_to_arg;
@ -192,7 +229,7 @@ impl AlwaysStatement {
let mut builder = UnitContext::builder(&mut unit_ctx.data);
let mut arg_value_to_raw_name = HashMap::new();
let mut raw_name_to_prb0 = HashMap::new();
let mut raw_name_to_prb_init = HashMap::new();
for (name, arg) in raw_name_to_arg {
let value = builder.arg_value(*arg);
builder.set_name(value, name.clone());
@ -227,7 +264,6 @@ impl AlwaysStatement {
let name = &arg_value_to_raw_name[x];
if rvalues.contains(name) {
let output_prb = builder.ins().prb(*x);
unamed_values.push(output_prb);
let output_shadow = builder.ins().suffix(*x, "shadow").var(output_prb);
raw_name_to_shadow.insert(name.clone(), output_shadow);
Some(output_shadow)
@ -248,8 +284,8 @@ impl AlwaysStatement {
.filter(|x| sensitivity_names.contains(&arg_value_to_raw_name[&x]))
.map(|x| {
let raw_name = &arg_value_to_raw_name[&x];
let prb = builder.ins().suffix(*x, "prb0").prb(*x);
raw_name_to_prb0.insert(raw_name, prb);
let prb = builder.ins().prb(*x);
raw_name_to_prb_init.insert(raw_name, prb);
prb
})
.collect();
@ -262,36 +298,30 @@ impl AlwaysStatement {
.zip(output_shadows.iter())
.for_each(|(output, output_shadow)| {
let output_prb = builder.ins().prb(*output);
unamed_values.push(output_prb);
builder.ins().st(*output_shadow, output_prb);
});
let mut zeros = HashMap::new();
let mut last_event = None;
for (i, (raw_name, tag, value_type)) in sensitivity_list_plus.iter().enumerate() {
let v = raw_name_to_value[raw_name];
let prb0 = raw_name_to_prb0[raw_name];
let prb = builder.ins().suffix(v, "prb").prb(v);
let prb_init = raw_name_to_prb_init[raw_name];
let prb = builder.ins().prb(v);
let (name, event) = if *tag == Tag::POS_EDGE || *tag == Tag::NEG_EDGE {
let zero = if zeros.contains_key(value_type) {
zeros[value_type]
} else {
let z = builder.ins().const_zero(value_type.unwrap_signal());
unamed_values.push(z);
zeros.insert(value_type.clone(), z);
z
};
let (mut n, v) = if *tag == Tag::POS_EDGE {
let eq = builder.ins().eq(prb0, zero);
let eq = builder.ins().eq(prb_init, zero);
let neq = builder.ins().neq(prb, zero);
unamed_values.push(eq);
unamed_values.push(neq);
(String::from("posedge"), builder.ins().and(eq, neq))
} else {
let neq = builder.ins().neq(prb0, zero);
let neq = builder.ins().neq(prb_init, zero);
let eq = builder.ins().eq(prb, zero);
unamed_values.push(neq);
unamed_values.push(eq);
(String::from("negedge"), builder.ins().and(neq, eq))
};
if i > 0 {
@ -304,7 +334,7 @@ impl AlwaysStatement {
} else {
String::from("impledge")
};
let v = builder.ins().neq(prb0, prb);
let v = builder.ins().neq(prb_init, prb);
(n, v)
};
builder.set_name(event, name);
@ -328,7 +358,6 @@ impl AlwaysStatement {
// initialize basic block "event"
builder.append_to(bb_event);
let delta_time = builder.ins().const_time(TimeValue::new(num::zero(), 1, 0));
unamed_values.push(delta_time);
unit_ctx.delta_time = Some(delta_time);
unit_ctx.bb_head.push(bb_event);

4
src/cst/context.rs
View File

@ -22,7 +22,6 @@ pub struct UnitContext {
pub raw_name_to_arg: HashMap<String, Arg>,
pub raw_name_to_value: HashMap<String, Value>,
pub raw_name_to_shadow: HashMap<String, Value>,
pub unamed_values: Vec<Value>,
pub delta_time: Option<Value>,
pub bb_head: Vec<Block>,
pub ty_active: Option<Type>,
@ -74,7 +73,6 @@ impl UnitContext {
raw_name_to_arg: HashMap::new(),
raw_name_to_value: HashMap::new(),
raw_name_to_shadow: HashMap::new(),
unamed_values: Vec::new(),
delta_time: None,
bb_head: Vec::new(),
ty_active: None,
@ -94,7 +92,6 @@ impl UnitContext {
self.raw_name_to_arg.clear();
self.raw_name_to_value.clear();
self.raw_name_to_shadow.clear();
self.unamed_values.clear();
self.delta_time = None;
self.bb_head.clear();
self.ty_active = None;
@ -107,7 +104,6 @@ impl UnitContext {
&& self.raw_name_to_arg.is_empty()
&& self.raw_name_to_value.is_empty()
&& self.raw_name_to_shadow.is_empty()
&& self.unamed_values.is_empty()
&& self.delta_time.is_none()
&& self.bb_head.is_empty()
&& self.ty_active.is_none()

38
src/cst/expression.rs
View File

@ -82,42 +82,15 @@ impl Expression {
let value = raw_name_to_value[&symbol];
let shadow = raw_name_to_shadow.get(&symbol).cloned();
let shadow_name = if shadow.is_some() {
let base_name = symbol.clone() + ".shadow.ld";
let count = raw_name_to_value
.keys()
.filter(|x| x.starts_with(base_name.as_str()))
.count();
if count == 0 {
base_name
} else {
format!("{}{}", base_name, count)
}
} else {
String::from("")
};
let mut builder = UnitContext::builder(&mut unit_ctx.data);
let bb_head = *unit_ctx.bb_head.last().unwrap();
builder.append_to(bb_head);
let ret = match shadow {
None => {
let value_name = symbol.clone() + ".prb";
let value_prb = builder.ins().prb(value);
builder.set_name(value_prb, value_name.clone());
raw_name_to_value.insert(value_name.clone(), value_prb);
value_prb
}
Some(s) => {
let shadow_ld = builder.ins().ld(s);
builder.set_name(shadow_ld, shadow_name.clone());
raw_name_to_value.insert(shadow_name.clone(), shadow_ld);
shadow_ld
}
};
Some(ret)
Some(match shadow {
None => builder.ins().prb(value),
Some(s) => builder.ins().ld(s),
})
} else {
None
}
@ -145,7 +118,6 @@ impl Expression {
.unwrap_int();
let v = json_child["text"].to_string().parse::<usize>().unwrap();
let num = builder.ins().const_int((w, v));
unit_ctx.unamed_values.push(num);
Some(num)
}
_ => panic!("unknown error at CST node '{}'", json_child),
@ -203,12 +175,10 @@ impl Expression {
match json_children[1]["tag"].as_str() {
Some("+") => {
let value = builder.ins().add(opd_l, opd_r);
unit_ctx.unamed_values.push(value);
Some(value)
}
Some("-") => {
let value = builder.ins().sub(opd_l, opd_r);
unit_ctx.unamed_values.push(value);
Some(value)
}
Some(tag) => {