1use std::{
2 borrow::Cow,
3 cell::RefCell,
4 collections::{HashMap, HashSet},
5};
6
7use crate::{design::TopoSortItem, Cell, ControlNet, Design, MetaItemId, ValueBit, Value};
8
9pub enum RewriteResult {
10 None,
11 Cell(Cell),
12 CellMeta(Cell, MetaItemId),
13 Value(Value),
14}
15
16impl From<Value> for RewriteResult {
17 fn from(value: Value) -> Self {
18 RewriteResult::Value(value)
19 }
20}
21
22impl From<ValueBit> for RewriteResult {
23 fn from(net: ValueBit) -> Self {
24 RewriteResult::Value(net.into())
25 }
26}
27
28impl From<ControlNet> for RewriteResult {
29 fn from(cnet: ControlNet) -> Self {
30 match cnet {
31 ControlNet::Pos(net) => RewriteResult::Value(net.into()),
32 ControlNet::Neg(net) => RewriteResult::Cell(Cell::Not(net.into())),
33 }
34 }
35}
36
37impl From<Cell> for RewriteResult {
38 fn from(cell: Cell) -> Self {
39 RewriteResult::Cell(cell)
40 }
41}
42
43pub enum RewriteNetSource<'a> {
44 Opaque,
45 Cell(Cow<'a, Cell>, MetaItemId, usize),
46}
47
48pub trait RewriteRuleset {
49 fn rewrite<'a>(
50 &self,
51 cell: &Cell,
52 meta: MetaItemId,
53 output: Option<&Value>,
54 rewriter: &Rewriter<'a>,
55 ) -> RewriteResult {
56 let _ = (cell, meta, output, rewriter);
57 RewriteResult::None
58 }
59 fn cell_added(&self, design: &Design, cell: &Cell, output: &Value) {
60 let _ = (design, cell, output);
61 }
62 fn net_replaced(&self, design: &Design, from: ValueBit, to: ValueBit) {
63 let _ = (design, from, to);
64 }
65}
66
67pub struct Rewriter<'a> {
68 design: &'a Design,
69 rules: &'a [&'a dyn RewriteRuleset],
70 processed: RefCell<HashSet<ValueBit>>,
71 cache: RefCell<HashMap<Cell, Value>>,
72}
73
74impl<'a> Rewriter<'a> {
75 pub fn find_cell(&self, net: ValueBit) -> RewriteNetSource<'a> {
76 if !self.processed.borrow().contains(&net) && !net.is_const() {
77 return RewriteNetSource::Opaque;
78 }
79 let (cell, meta, bit) = self.design.find_new_cell(net);
80 RewriteNetSource::Cell(cell, meta, bit)
81 }
82
83 fn process_cell(&self, cell: &Cell, meta: MetaItemId, output: Option<&Value>) -> RewriteResult {
84 let mut replacement_cell = None;
85 let mut replacement_meta = None;
86 'outer: loop {
87 for &rule in self.rules {
88 let cur_cell = replacement_cell.as_ref().unwrap_or(cell);
89 let cur_meta = replacement_meta.unwrap_or(meta);
90 let _guard = self.design.use_metadata(cur_meta);
91 match rule.rewrite(cur_cell, cur_meta, output, self) {
92 RewriteResult::None => (),
93 RewriteResult::Cell(new_cell) => {
94 replacement_cell = Some(new_cell);
95 continue 'outer;
96 }
97 RewriteResult::CellMeta(new_cell, new_meta) => {
98 replacement_cell = Some(new_cell);
99 replacement_meta = Some(new_meta);
100 continue 'outer;
101 }
102 RewriteResult::Value(value) => {
103 return RewriteResult::Value(value);
104 }
105 }
106 }
107 break;
108 }
109 let cell = replacement_cell.as_ref().unwrap_or(cell);
110 if let Some(value) = self.cache.borrow().get(cell) {
111 let meta = replacement_meta.unwrap_or(meta);
112 self.design.append_metadata_by_net(value[0], meta);
113 RewriteResult::Value(value.clone())
114 } else {
115 match (replacement_cell, replacement_meta) {
116 (None, _) => RewriteResult::None,
117 (Some(cell), None) => RewriteResult::Cell(cell),
118 (Some(cell), Some(meta)) => RewriteResult::CellMeta(cell, meta),
119 }
120 }
121 }
122
123 pub fn add_cell(&self, cell: Cell) -> Value {
124 self.add_cell_meta(cell, self.design.get_use_metadata())
125 }
126
127 pub fn add_cell_meta(&self, cell: Cell, meta: MetaItemId) -> Value {
128 self.add_cell_meta_output(cell, meta, None)
129 }
130
131 fn add_cell_meta_output(&self, cell: Cell, meta: MetaItemId, output: Option<&Value>) -> Value {
132 let (cell, meta) = match self.process_cell(&cell, meta, output) {
133 RewriteResult::None => (cell, meta),
134 RewriteResult::Cell(new_cell) => (new_cell, meta),
135 RewriteResult::CellMeta(new_cell, new_meta) => (new_cell, new_meta),
136 RewriteResult::Value(value) => return value,
137 };
138 let value = self.design.add_cell_with_metadata_id(cell.clone(), meta);
139 for &rule in self.rules {
140 rule.cell_added(self.design, &cell, &value);
141 }
142 for net in &value {
143 self.processed.borrow_mut().insert(net);
144 }
145 if !cell.has_effects(self.design) {
146 self.cache.borrow_mut().insert(cell, value.clone());
147 }
148 value
149 }
150
151 pub fn meta_from_merge(&self, iter: impl IntoIterator<Item = MetaItemId>) -> MetaItemId {
152 self.design.meta_from_merge(iter)
153 }
154
155 fn run(&mut self) {
156 let worklist = self.design.topo_sort();
157 for item in worklist {
158 match item {
159 TopoSortItem::Cell(cell_id) => {
160 let output = self.design.cell_output(cell_id);
161 let mut cell = self.design.cell(cell_id).into_owned();
162 cell.visit_mut(|net| *net = self.design.map_net_new(*net));
163 match self.process_cell(&cell, self.design.cell_metadata(cell_id), Some(&output)) {
164 RewriteResult::None => {
165 for &rule in self.rules {
166 rule.cell_added(self.design, &cell, &output);
167 }
168 if !cell.has_effects(self.design) {
169 self.cache.borrow_mut().insert(cell, output.clone());
170 }
171 for net in output {
172 self.processed.borrow_mut().insert(net);
173 }
174 }
175 RewriteResult::Cell(new_cell) => {
176 self.design.cell_replace(cell_id, new_cell.clone());
177 for &rule in self.rules {
178 rule.cell_added(self.design, &new_cell, &output);
179 }
180 if !new_cell.has_effects(self.design) {
181 self.cache.borrow_mut().insert(new_cell, output.clone());
182 }
183 for net in output {
184 self.processed.borrow_mut().insert(net);
185 }
186 }
187 RewriteResult::CellMeta(new_cell, new_meta) => {
188 self.design.cell_replace(cell_id, new_cell.clone());
189 for &rule in self.rules {
190 rule.cell_added(self.design, &new_cell, &output);
191 }
192 self.design.cell_append_metadata(cell_id, new_meta);
193 if !new_cell.has_effects(self.design) {
194 self.cache.borrow_mut().insert(new_cell, output.clone());
195 }
196 for net in output {
197 self.processed.borrow_mut().insert(net);
198 }
199 }
200 RewriteResult::Value(value) => {
201 assert_eq!(value.len(), output.len());
202 for (net, new_net) in output.iter().zip(value) {
203 self.design.replace_net(net, new_net);
204 for &rule in self.rules {
205 rule.net_replaced(self.design, net, new_net);
206 }
207 self.processed.borrow_mut().insert(net);
208 }
209 self.design.cell_unalive(cell_id);
210 }
211 }
212 }
213 TopoSortItem::CellBit(cell, bit) => {
214 let mut slice = self.design.cell(cell).slice(bit..bit + 1).unwrap();
215 slice.visit_mut(|net| *net = self.design.map_net_new(*net));
216 let net = self.design.cell_output(cell)[bit];
217 let new_value =
218 self.add_cell_meta_output(slice, self.design.cell_metadata(cell), Some(&net.into()));
219 let new_net = new_value[0];
220 self.design.replace_net(net, new_net);
221 for &rule in self.rules {
222 rule.net_replaced(self.design, net, new_net);
223 }
224 self.processed.borrow_mut().insert(net);
225 }
226 }
227 }
228 }
229}
230
231impl Design {
232 pub fn rewrite(&mut self, rules: &[&dyn RewriteRuleset]) {
233 assert!(!self.is_changed());
234 let mut rewriter = Rewriter {
235 design: self,
236 rules,
237 processed: RefCell::new(HashSet::new()),
238 cache: RefCell::new(HashMap::new()),
239 };
240 rewriter.run();
241 self.compact();
242 }
243}