projects / yosys.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'master' into clifford/fix1255
[yosys.git] / kernel / satgen.h
1 /* -*- c++ -*-
2 * yosys -- Yosys Open SYnthesis Suite
3 *
4 * Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 *
18 */
19
20 #ifndef SATGEN_H
21 #define SATGEN_H
22
23 #include "kernel/rtlil.h"
24 #include "kernel/sigtools.h"
25 #include "kernel/celltypes.h"
26 #include "kernel/macc.h"
27
28 #include "libs/ezsat/ezminisat.h"
29
30 YOSYS_NAMESPACE_BEGIN
31
32 // defined in kernel/register.cc
33 extern struct SatSolver *yosys_satsolver_list;
34 extern struct SatSolver *yosys_satsolver;
35
36 struct SatSolver
37 {
38 string name;
39 SatSolver *next;
40 virtual ezSAT *create() = 0;
41
42 SatSolver(string name) : name(name) {
43 next = yosys_satsolver_list;
44 yosys_satsolver_list = this;
45 }
46
47 virtual ~SatSolver() {
48 auto p = &yosys_satsolver_list;
49 while (*p) {
50 if (*p == this)
51 *p = next;
52 else
53 p = &(*p)->next;
54 }
55 if (yosys_satsolver == this)
56 yosys_satsolver = yosys_satsolver_list;
57 }
58 };
59
60 struct ezSatPtr : public std::unique_ptr<ezSAT> {
61 ezSatPtr() : unique_ptr<ezSAT>(yosys_satsolver->create()) { }
62 };
63
64 struct SatGen
65 {
66 ezSAT *ez;
67 SigMap *sigmap;
68 std::string prefix;
69 SigPool initial_state;
70 std::map<std::string, RTLIL::SigSpec> asserts_a, asserts_en;
71 std::map<std::string, RTLIL::SigSpec> assumes_a, assumes_en;
72 std::map<std::string, std::map<RTLIL::SigBit, int>> imported_signals;
73 std::map<std::pair<std::string, int>, bool> initstates;
74 bool ignore_div_by_zero;
75 bool model_undef;
76
77 SatGen(ezSAT *ez, SigMap *sigmap, std::string prefix = std::string()) :
78 ez(ez), sigmap(sigmap), prefix(prefix), ignore_div_by_zero(false), model_undef(false)
79 {
80 }
81
82 void setContext(SigMap *sigmap, std::string prefix = std::string())
83 {
84 this->sigmap = sigmap;
85 this->prefix = prefix;
86 }
87
88 std::vector<int> importSigSpecWorker(RTLIL::SigSpec sig, std::string &pf, bool undef_mode, bool dup_undef)
89 {
90 log_assert(!undef_mode || model_undef);
91 sigmap->apply(sig);
92
93 std::vector<int> vec;
94 vec.reserve(GetSize(sig));
95
96 for (auto &bit : sig)
97 if (bit.wire == NULL) {
98 if (model_undef && dup_undef && bit == RTLIL::State::Sx)
99 vec.push_back(ez->frozen_literal());
100 else
101 vec.push_back(bit == (undef_mode ? RTLIL::State::Sx : RTLIL::State::S1) ? ez->CONST_TRUE : ez->CONST_FALSE);
102 } else {
103 std::string name = pf + (bit.wire->width == 1 ? stringf("%s", log_id(bit.wire)) : stringf("%s [%d]", log_id(bit.wire->name), bit.offset));
104 vec.push_back(ez->frozen_literal(name));
105 imported_signals[pf][bit] = vec.back();
106 }
107 return vec;
108 }
109
110 std::vector<int> importSigSpec(RTLIL::SigSpec sig, int timestep = -1)
111 {
112 log_assert(timestep != 0);
113 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
114 return importSigSpecWorker(sig, pf, false, false);
115 }
116
117 std::vector<int> importDefSigSpec(RTLIL::SigSpec sig, int timestep = -1)
118 {
119 log_assert(timestep != 0);
120 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
121 return importSigSpecWorker(sig, pf, false, true);
122 }
123
124 std::vector<int> importUndefSigSpec(RTLIL::SigSpec sig, int timestep = -1)
125 {
126 log_assert(timestep != 0);
127 std::string pf = "undef:" + prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
128 return importSigSpecWorker(sig, pf, true, false);
129 }
130
131 int importSigBit(RTLIL::SigBit bit, int timestep = -1)
132 {
133 log_assert(timestep != 0);
134 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
135 return importSigSpecWorker(bit, pf, false, false).front();
136 }
137
138 int importDefSigBit(RTLIL::SigBit bit, int timestep = -1)
139 {
140 log_assert(timestep != 0);
141 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
142 return importSigSpecWorker(bit, pf, false, true).front();
143 }
144
145 int importUndefSigBit(RTLIL::SigBit bit, int timestep = -1)
146 {
147 log_assert(timestep != 0);
148 std::string pf = "undef:" + prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
149 return importSigSpecWorker(bit, pf, true, false).front();
150 }
151
152 bool importedSigBit(RTLIL::SigBit bit, int timestep = -1)
153 {
154 log_assert(timestep != 0);
155 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
156 return imported_signals[pf].count(bit) != 0;
157 }
158
159 void getAsserts(RTLIL::SigSpec &sig_a, RTLIL::SigSpec &sig_en, int timestep = -1)
160 {
161 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
162 sig_a = asserts_a[pf];
163 sig_en = asserts_en[pf];
164 }
165
166 void getAssumes(RTLIL::SigSpec &sig_a, RTLIL::SigSpec &sig_en, int timestep = -1)
167 {
168 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
169 sig_a = assumes_a[pf];
170 sig_en = assumes_en[pf];
171 }
172
173 int importAsserts(int timestep = -1)
174 {
175 std::vector<int> check_bits, enable_bits;
176 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
177 if (model_undef) {
178 check_bits = ez->vec_and(ez->vec_not(importUndefSigSpec(asserts_a[pf], timestep)), importDefSigSpec(asserts_a[pf], timestep));
179 enable_bits = ez->vec_and(ez->vec_not(importUndefSigSpec(asserts_en[pf], timestep)), importDefSigSpec(asserts_en[pf], timestep));
180 } else {
181 check_bits = importDefSigSpec(asserts_a[pf], timestep);
182 enable_bits = importDefSigSpec(asserts_en[pf], timestep);
183 }
184 return ez->vec_reduce_and(ez->vec_or(check_bits, ez->vec_not(enable_bits)));
185 }
186
187 int importAssumes(int timestep = -1)
188 {
189 std::vector<int> check_bits, enable_bits;
190 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
191 if (model_undef) {
192 check_bits = ez->vec_and(ez->vec_not(importUndefSigSpec(assumes_a[pf], timestep)), importDefSigSpec(assumes_a[pf], timestep));
193 enable_bits = ez->vec_and(ez->vec_not(importUndefSigSpec(assumes_en[pf], timestep)), importDefSigSpec(assumes_en[pf], timestep));
194 } else {
195 check_bits = importDefSigSpec(assumes_a[pf], timestep);
196 enable_bits = importDefSigSpec(assumes_en[pf], timestep);
197 }
198 return ez->vec_reduce_and(ez->vec_or(check_bits, ez->vec_not(enable_bits)));
199 }
200
201 int signals_eq(RTLIL::SigSpec lhs, RTLIL::SigSpec rhs, int timestep_lhs = -1, int timestep_rhs = -1)
202 {
203 if (timestep_rhs < 0)
204 timestep_rhs = timestep_lhs;
205
206 log_assert(lhs.size() == rhs.size());
207
208 std::vector<int> vec_lhs = importSigSpec(lhs, timestep_lhs);
209 std::vector<int> vec_rhs = importSigSpec(rhs, timestep_rhs);
210
211 if (!model_undef)
212 return ez->vec_eq(vec_lhs, vec_rhs);
213
214 std::vector<int> undef_lhs = importUndefSigSpec(lhs, timestep_lhs);
215 std::vector<int> undef_rhs = importUndefSigSpec(rhs, timestep_rhs);
216
217 std::vector<int> eq_bits;
218 for (int i = 0; i < lhs.size(); i++)
219 eq_bits.push_back(ez->AND(ez->IFF(undef_lhs.at(i), undef_rhs.at(i)),
220 ez->IFF(ez->OR(vec_lhs.at(i), undef_lhs.at(i)), ez->OR(vec_rhs.at(i), undef_rhs.at(i)))));
221 return ez->expression(ezSAT::OpAnd, eq_bits);
222 }
223
224 void extendSignalWidth(std::vector<int> &vec_a, std::vector<int> &vec_b, RTLIL::Cell *cell, size_t y_width = 0, bool forced_signed = false)
225 {
226 bool is_signed = forced_signed;
227 if (!forced_signed && cell->parameters.count(ID(A_SIGNED)) > 0 && cell->parameters.count(ID(B_SIGNED)) > 0)
228 is_signed = cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool();
229 while (vec_a.size() < vec_b.size() || vec_a.size() < y_width)
230 vec_a.push_back(is_signed && vec_a.size() > 0 ? vec_a.back() : ez->CONST_FALSE);
231 while (vec_b.size() < vec_a.size() || vec_b.size() < y_width)
232 vec_b.push_back(is_signed && vec_b.size() > 0 ? vec_b.back() : ez->CONST_FALSE);
233 }
234
235 void extendSignalWidth(std::vector<int> &vec_a, std::vector<int> &vec_b, std::vector<int> &vec_y, RTLIL::Cell *cell, bool forced_signed = false)
236 {
237 extendSignalWidth(vec_a, vec_b, cell, vec_y.size(), forced_signed);
238 while (vec_y.size() < vec_a.size())
239 vec_y.push_back(ez->literal());
240 }
241
242 void extendSignalWidthUnary(std::vector<int> &vec_a, std::vector<int> &vec_y, RTLIL::Cell *cell, bool forced_signed = false)
243 {
244 bool is_signed = forced_signed || (cell->parameters.count(ID(A_SIGNED)) > 0 && cell->parameters[ID(A_SIGNED)].as_bool());
245 while (vec_a.size() < vec_y.size())
246 vec_a.push_back(is_signed && vec_a.size() > 0 ? vec_a.back() : ez->CONST_FALSE);
247 while (vec_y.size() < vec_a.size())
248 vec_y.push_back(ez->literal());
249 }
250
251 void undefGating(std::vector<int> &vec_y, std::vector<int> &vec_yy, std::vector<int> &vec_undef)
252 {
253 log_assert(model_undef);
254 log_assert(vec_y.size() == vec_yy.size());
255 if (vec_y.size() > vec_undef.size()) {
256 std::vector<int> trunc_y(vec_y.begin(), vec_y.begin() + vec_undef.size());
257 std::vector<int> trunc_yy(vec_yy.begin(), vec_yy.begin() + vec_undef.size());
258 ez->assume(ez->expression(ezSAT::OpAnd, ez->vec_or(vec_undef, ez->vec_iff(trunc_y, trunc_yy))));
259 } else {
260 log_assert(vec_y.size() == vec_undef.size());
261 ez->assume(ez->expression(ezSAT::OpAnd, ez->vec_or(vec_undef, ez->vec_iff(vec_y, vec_yy))));
262 }
263 }
264
265 void undefGating(int y, int yy, int undef)
266 {
267 ez->assume(ez->OR(undef, ez->IFF(y, yy)));
268 }
269
270 void setInitState(int timestep)
271 {
272 auto key = make_pair(prefix, timestep);
273 log_assert(initstates.count(key) == 0 || initstates.at(key) == true);
274 initstates[key] = true;
275 }
276
277 bool importCell(RTLIL::Cell *cell, int timestep = -1)
278 {
279 bool arith_undef_handled = false;
280 bool is_arith_compare = cell->type.in(ID($lt), ID($le), ID($ge), ID($gt));
281
282 if (model_undef && (cell->type.in(ID($add), ID($sub), ID($mul), ID($div), ID($mod)) || is_arith_compare))
283 {
284 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
285 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
286 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
287 if (is_arith_compare)
288 extendSignalWidth(undef_a, undef_b, cell, true);
289 else
290 extendSignalWidth(undef_a, undef_b, undef_y, cell, true);
291
292 int undef_any_a = ez->expression(ezSAT::OpOr, undef_a);
293 int undef_any_b = ez->expression(ezSAT::OpOr, undef_b);
294 int undef_y_bit = ez->OR(undef_any_a, undef_any_b);
295
296 if (cell->type == ID($div) || cell->type == ID($mod)) {
297 std::vector<int> b = importSigSpec(cell->getPort(ID(B)), timestep);
298 undef_y_bit = ez->OR(undef_y_bit, ez->NOT(ez->expression(ezSAT::OpOr, b)));
299 }
300
301 if (is_arith_compare) {
302 for (size_t i = 1; i < undef_y.size(); i++)
303 ez->SET(ez->CONST_FALSE, undef_y.at(i));
304 ez->SET(undef_y_bit, undef_y.at(0));
305 } else {
306 std::vector<int> undef_y_bits(undef_y.size(), undef_y_bit);
307 ez->assume(ez->vec_eq(undef_y_bits, undef_y));
308 }
309
310 arith_undef_handled = true;
311 }
312
313 if (cell->type.in(ID($_AND_), ID($_NAND_), ID($_OR_), ID($_NOR_), ID($_XOR_), ID($_XNOR_), ID($_ANDNOT_), ID($_ORNOT_),
314 ID($and), ID($or), ID($xor), ID($xnor), ID($add), ID($sub)))
315 {
316 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
317 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
318 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
319 extendSignalWidth(a, b, y, cell);
320
321 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
322
323 if (cell->type == ID($and) || cell->type == ID($_AND_))
324 ez->assume(ez->vec_eq(ez->vec_and(a, b), yy));
325 if (cell->type == ID($_NAND_))
326 ez->assume(ez->vec_eq(ez->vec_not(ez->vec_and(a, b)), yy));
327 if (cell->type == ID($or) || cell->type == ID($_OR_))
328 ez->assume(ez->vec_eq(ez->vec_or(a, b), yy));
329 if (cell->type == ID($_NOR_))
330 ez->assume(ez->vec_eq(ez->vec_not(ez->vec_or(a, b)), yy));
331 if (cell->type == ID($xor) || cell->type == ID($_XOR_))
332 ez->assume(ez->vec_eq(ez->vec_xor(a, b), yy));
333 if (cell->type == ID($xnor) || cell->type == ID($_XNOR_))
334 ez->assume(ez->vec_eq(ez->vec_not(ez->vec_xor(a, b)), yy));
335 if (cell->type == ID($_ANDNOT_))
336 ez->assume(ez->vec_eq(ez->vec_and(a, ez->vec_not(b)), yy));
337 if (cell->type == ID($_ORNOT_))
338 ez->assume(ez->vec_eq(ez->vec_or(a, ez->vec_not(b)), yy));
339 if (cell->type == ID($add))
340 ez->assume(ez->vec_eq(ez->vec_add(a, b), yy));
341 if (cell->type == ID($sub))
342 ez->assume(ez->vec_eq(ez->vec_sub(a, b), yy));
343
344 if (model_undef && !arith_undef_handled)
345 {
346 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
347 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
348 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
349 extendSignalWidth(undef_a, undef_b, undef_y, cell, false);
350
351 if (cell->type.in(ID($and), ID($_AND_), ID($_NAND_))) {
352 std::vector<int> a0 = ez->vec_and(ez->vec_not(a), ez->vec_not(undef_a));
353 std::vector<int> b0 = ez->vec_and(ez->vec_not(b), ez->vec_not(undef_b));
354 std::vector<int> yX = ez->vec_and(ez->vec_or(undef_a, undef_b), ez->vec_not(ez->vec_or(a0, b0)));
355 ez->assume(ez->vec_eq(yX, undef_y));
356 }
357 else if (cell->type.in(ID($or), ID($_OR_), ID($_NOR_))) {
358 std::vector<int> a1 = ez->vec_and(a, ez->vec_not(undef_a));
359 std::vector<int> b1 = ez->vec_and(b, ez->vec_not(undef_b));
360 std::vector<int> yX = ez->vec_and(ez->vec_or(undef_a, undef_b), ez->vec_not(ez->vec_or(a1, b1)));
361 ez->assume(ez->vec_eq(yX, undef_y));
362 }
363 else if (cell->type.in(ID($xor), ID($xnor), ID($_XOR_), ID($_XNOR_))) {
364 std::vector<int> yX = ez->vec_or(undef_a, undef_b);
365 ez->assume(ez->vec_eq(yX, undef_y));
366 }
367 else if (cell->type == ID($_ANDNOT_)) {
368 std::vector<int> a0 = ez->vec_and(ez->vec_not(a), ez->vec_not(undef_a));
369 std::vector<int> b1 = ez->vec_and(b, ez->vec_not(undef_b));
370 std::vector<int> yX = ez->vec_and(ez->vec_or(undef_a, undef_b), ez->vec_not(ez->vec_or(a0, b1)));
371 ez->assume(ez->vec_eq(yX, undef_y));
372 }
373
374 else if (cell->type == ID($_ORNOT_)) {
375 std::vector<int> a1 = ez->vec_and(a, ez->vec_not(undef_a));
376 std::vector<int> b0 = ez->vec_and(ez->vec_not(b), ez->vec_not(undef_b));
377 std::vector<int> yX = ez->vec_and(ez->vec_or(undef_a, undef_b), ez->vec_not(ez->vec_or(a1, b0)));
378 ez->assume(ez->vec_eq(yX, undef_y));
379 }
380 else
381 log_abort();
382
383 undefGating(y, yy, undef_y);
384 }
385 else if (model_undef)
386 {
387 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
388 undefGating(y, yy, undef_y);
389 }
390 return true;
391 }
392
393 if (cell->type.in(ID($_AOI3_), ID($_OAI3_), ID($_AOI4_), ID($_OAI4_)))
394 {
395 bool aoi_mode = cell->type.in(ID($_AOI3_), ID($_AOI4_));
396 bool three_mode = cell->type.in(ID($_AOI3_), ID($_OAI3_));
397
398 int a = importDefSigSpec(cell->getPort(ID(A)), timestep).at(0);
399 int b = importDefSigSpec(cell->getPort(ID(B)), timestep).at(0);
400 int c = importDefSigSpec(cell->getPort(ID(C)), timestep).at(0);
401 int d = three_mode ? (aoi_mode ? ez->CONST_TRUE : ez->CONST_FALSE) : importDefSigSpec(cell->getPort(ID(D)), timestep).at(0);
402 int y = importDefSigSpec(cell->getPort(ID(Y)), timestep).at(0);
403 int yy = model_undef ? ez->literal() : y;
404
405 if (cell->type.in(ID($_AOI3_), ID($_AOI4_)))
406 ez->assume(ez->IFF(ez->NOT(ez->OR(ez->AND(a, b), ez->AND(c, d))), yy));
407 else
408 ez->assume(ez->IFF(ez->NOT(ez->AND(ez->OR(a, b), ez->OR(c, d))), yy));
409
410 if (model_undef)
411 {
412 int undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep).at(0);
413 int undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep).at(0);
414 int undef_c = importUndefSigSpec(cell->getPort(ID(C)), timestep).at(0);
415 int undef_d = three_mode ? ez->CONST_FALSE : importUndefSigSpec(cell->getPort(ID(D)), timestep).at(0);
416 int undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep).at(0);
417
418 if (aoi_mode)
419 {
420 int a0 = ez->AND(ez->NOT(a), ez->NOT(undef_a));
421 int b0 = ez->AND(ez->NOT(b), ez->NOT(undef_b));
422 int c0 = ez->AND(ez->NOT(c), ez->NOT(undef_c));
423 int d0 = ez->AND(ez->NOT(d), ez->NOT(undef_d));
424
425 int ab = ez->AND(a, b), cd = ez->AND(c, d);
426 int undef_ab = ez->AND(ez->OR(undef_a, undef_b), ez->NOT(ez->OR(a0, b0)));
427 int undef_cd = ez->AND(ez->OR(undef_c, undef_d), ez->NOT(ez->OR(c0, d0)));
428
429 int ab1 = ez->AND(ab, ez->NOT(undef_ab));
430 int cd1 = ez->AND(cd, ez->NOT(undef_cd));
431 int yX = ez->AND(ez->OR(undef_ab, undef_cd), ez->NOT(ez->OR(ab1, cd1)));
432
433 ez->assume(ez->IFF(yX, undef_y));
434 }
435 else
436 {
437 int a1 = ez->AND(a, ez->NOT(undef_a));
438 int b1 = ez->AND(b, ez->NOT(undef_b));
439 int c1 = ez->AND(c, ez->NOT(undef_c));
440 int d1 = ez->AND(d, ez->NOT(undef_d));
441
442 int ab = ez->OR(a, b), cd = ez->OR(c, d);
443 int undef_ab = ez->AND(ez->OR(undef_a, undef_b), ez->NOT(ez->OR(a1, b1)));
444 int undef_cd = ez->AND(ez->OR(undef_c, undef_d), ez->NOT(ez->OR(c1, d1)));
445
446 int ab0 = ez->AND(ez->NOT(ab), ez->NOT(undef_ab));
447 int cd0 = ez->AND(ez->NOT(cd), ez->NOT(undef_cd));
448 int yX = ez->AND(ez->OR(undef_ab, undef_cd), ez->NOT(ez->OR(ab0, cd0)));
449
450 ez->assume(ez->IFF(yX, undef_y));
451 }
452
453 undefGating(y, yy, undef_y);
454 }
455
456 return true;
457 }
458
459 if (cell->type == ID($_NOT_) || cell->type == ID($not))
460 {
461 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
462 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
463 extendSignalWidthUnary(a, y, cell);
464
465 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
466 ez->assume(ez->vec_eq(ez->vec_not(a), yy));
467
468 if (model_undef) {
469 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
470 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
471 extendSignalWidthUnary(undef_a, undef_y, cell, false);
472 ez->assume(ez->vec_eq(undef_a, undef_y));
473 undefGating(y, yy, undef_y);
474 }
475 return true;
476 }
477
478 if (cell->type == ID($_MUX_) || cell->type == ID($mux) || cell->type == ID($_NMUX_))
479 {
480 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
481 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
482 std::vector<int> s = importDefSigSpec(cell->getPort(ID(S)), timestep);
483 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
484
485 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
486 if (cell->type == ID($_NMUX_))
487 ez->assume(ez->vec_eq(ez->vec_not(ez->vec_ite(s.at(0), b, a)), yy));
488 else
489 ez->assume(ez->vec_eq(ez->vec_ite(s.at(0), b, a), yy));
490
491 if (model_undef)
492 {
493 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
494 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
495 std::vector<int> undef_s = importUndefSigSpec(cell->getPort(ID(S)), timestep);
496 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
497
498 std::vector<int> unequal_ab = ez->vec_not(ez->vec_iff(a, b));
499 std::vector<int> undef_ab = ez->vec_or(unequal_ab, ez->vec_or(undef_a, undef_b));
500 std::vector<int> yX = ez->vec_ite(undef_s.at(0), undef_ab, ez->vec_ite(s.at(0), undef_b, undef_a));
501 ez->assume(ez->vec_eq(yX, undef_y));
502 undefGating(y, yy, undef_y);
503 }
504 return true;
505 }
506
507 if (cell->type == ID($pmux))
508 {
509 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
510 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
511 std::vector<int> s = importDefSigSpec(cell->getPort(ID(S)), timestep);
512 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
513
514 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
515
516 std::vector<int> tmp = a;
517 for (size_t i = 0; i < s.size(); i++) {
518 std::vector<int> part_of_b(b.begin()+i*a.size(), b.begin()+(i+1)*a.size());
519 tmp = ez->vec_ite(s.at(i), part_of_b, tmp);
520 }
521 ez->assume(ez->vec_eq(tmp, yy));
522
523 if (model_undef)
524 {
525 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
526 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
527 std::vector<int> undef_s = importUndefSigSpec(cell->getPort(ID(S)), timestep);
528 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
529
530 int maybe_a = ez->CONST_TRUE;
531
532 std::vector<int> bits_set = std::vector<int>(undef_y.size(), ez->CONST_FALSE);
533 std::vector<int> bits_clr = std::vector<int>(undef_y.size(), ez->CONST_FALSE);
534
535 for (size_t i = 0; i < s.size(); i++)
536 {
537 std::vector<int> part_of_b(b.begin()+i*a.size(), b.begin()+(i+1)*a.size());
538 std::vector<int> part_of_undef_b(undef_b.begin()+i*a.size(), undef_b.begin()+(i+1)*a.size());
539
540 int maybe_s = ez->OR(s.at(i), undef_s.at(i));
541 int sure_s = ez->AND(s.at(i), ez->NOT(undef_s.at(i)));
542
543 maybe_a = ez->AND(maybe_a, ez->NOT(sure_s));
544
545 bits_set = ez->vec_ite(maybe_s, ez->vec_or(bits_set, ez->vec_or(part_of_b, part_of_undef_b)), bits_set);
546 bits_clr = ez->vec_ite(maybe_s, ez->vec_or(bits_clr, ez->vec_or(ez->vec_not(part_of_b), part_of_undef_b)), bits_clr);
547 }
548
549 bits_set = ez->vec_ite(maybe_a, ez->vec_or(bits_set, ez->vec_or(bits_set, ez->vec_or(a, undef_a))), bits_set);
550 bits_clr = ez->vec_ite(maybe_a, ez->vec_or(bits_clr, ez->vec_or(bits_clr, ez->vec_or(ez->vec_not(a), undef_a))), bits_clr);
551
552 ez->assume(ez->vec_eq(ez->vec_not(ez->vec_xor(bits_set, bits_clr)), undef_y));
553 undefGating(y, yy, undef_y);
554 }
555 return true;
556 }
557
558 if (cell->type == ID($pos) || cell->type == ID($neg))
559 {
560 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
561 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
562 extendSignalWidthUnary(a, y, cell);
563
564 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
565
566 if (cell->type == ID($pos)) {
567 ez->assume(ez->vec_eq(a, yy));
568 } else {
569 std::vector<int> zero(a.size(), ez->CONST_FALSE);
570 ez->assume(ez->vec_eq(ez->vec_sub(zero, a), yy));
571 }
572
573 if (model_undef)
574 {
575 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
576 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
577 extendSignalWidthUnary(undef_a, undef_y, cell);
578
579 if (cell->type == ID($pos)) {
580 ez->assume(ez->vec_eq(undef_a, undef_y));
581 } else {
582 int undef_any_a = ez->expression(ezSAT::OpOr, undef_a);
583 std::vector<int> undef_y_bits(undef_y.size(), undef_any_a);
584 ez->assume(ez->vec_eq(undef_y_bits, undef_y));
585 }
586
587 undefGating(y, yy, undef_y);
588 }
589 return true;
590 }
591
592 if (cell->type == ID($reduce_and) || cell->type == ID($reduce_or) || cell->type == ID($reduce_xor) ||
593 cell->type == ID($reduce_xnor) || cell->type == ID($reduce_bool) || cell->type == ID($logic_not))
594 {
595 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
596 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
597
598 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
599
600 if (cell->type == ID($reduce_and))
601 ez->SET(ez->expression(ez->OpAnd, a), yy.at(0));
602 if (cell->type == ID($reduce_or) || cell->type == ID($reduce_bool))
603 ez->SET(ez->expression(ez->OpOr, a), yy.at(0));
604 if (cell->type == ID($reduce_xor))
605 ez->SET(ez->expression(ez->OpXor, a), yy.at(0));
606 if (cell->type == ID($reduce_xnor))
607 ez->SET(ez->NOT(ez->expression(ez->OpXor, a)), yy.at(0));
608 if (cell->type == ID($logic_not))
609 ez->SET(ez->NOT(ez->expression(ez->OpOr, a)), yy.at(0));
610 for (size_t i = 1; i < y.size(); i++)
611 ez->SET(ez->CONST_FALSE, yy.at(i));
612
613 if (model_undef)
614 {
615 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
616 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
617 int aX = ez->expression(ezSAT::OpOr, undef_a);
618
619 if (cell->type == ID($reduce_and)) {
620 int a0 = ez->expression(ezSAT::OpOr, ez->vec_and(ez->vec_not(a), ez->vec_not(undef_a)));
621 ez->assume(ez->IFF(ez->AND(ez->NOT(a0), aX), undef_y.at(0)));
622 }
623 else if (cell->type == ID($reduce_or) || cell->type == ID($reduce_bool) || cell->type == ID($logic_not)) {
624 int a1 = ez->expression(ezSAT::OpOr, ez->vec_and(a, ez->vec_not(undef_a)));
625 ez->assume(ez->IFF(ez->AND(ez->NOT(a1), aX), undef_y.at(0)));
626 }
627 else if (cell->type == ID($reduce_xor) || cell->type == ID($reduce_xnor)) {
628 ez->assume(ez->IFF(aX, undef_y.at(0)));
629 } else
630 log_abort();
631
632 for (size_t i = 1; i < undef_y.size(); i++)
633 ez->SET(ez->CONST_FALSE, undef_y.at(i));
634
635 undefGating(y, yy, undef_y);
636 }
637 return true;
638 }
639
640 if (cell->type == ID($logic_and) || cell->type == ID($logic_or))
641 {
642 std::vector<int> vec_a = importDefSigSpec(cell->getPort(ID(A)), timestep);
643 std::vector<int> vec_b = importDefSigSpec(cell->getPort(ID(B)), timestep);
644
645 int a = ez->expression(ez->OpOr, vec_a);
646 int b = ez->expression(ez->OpOr, vec_b);
647 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
648
649 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
650
651 if (cell->type == ID($logic_and))
652 ez->SET(ez->expression(ez->OpAnd, a, b), yy.at(0));
653 else
654 ez->SET(ez->expression(ez->OpOr, a, b), yy.at(0));
655 for (size_t i = 1; i < y.size(); i++)
656 ez->SET(ez->CONST_FALSE, yy.at(i));
657
658 if (model_undef)
659 {
660 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
661 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
662 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
663
664 int a0 = ez->NOT(ez->OR(ez->expression(ezSAT::OpOr, vec_a), ez->expression(ezSAT::OpOr, undef_a)));
665 int b0 = ez->NOT(ez->OR(ez->expression(ezSAT::OpOr, vec_b), ez->expression(ezSAT::OpOr, undef_b)));
666 int a1 = ez->expression(ezSAT::OpOr, ez->vec_and(vec_a, ez->vec_not(undef_a)));
667 int b1 = ez->expression(ezSAT::OpOr, ez->vec_and(vec_b, ez->vec_not(undef_b)));
668 int aX = ez->expression(ezSAT::OpOr, undef_a);
669 int bX = ez->expression(ezSAT::OpOr, undef_b);
670
671 if (cell->type == ID($logic_and))
672 ez->SET(ez->AND(ez->OR(aX, bX), ez->NOT(ez->AND(a1, b1)), ez->NOT(a0), ez->NOT(b0)), undef_y.at(0));
673 else if (cell->type == ID($logic_or))
674 ez->SET(ez->AND(ez->OR(aX, bX), ez->NOT(ez->AND(a0, b0)), ez->NOT(a1), ez->NOT(b1)), undef_y.at(0));
675 else
676 log_abort();
677
678 for (size_t i = 1; i < undef_y.size(); i++)
679 ez->SET(ez->CONST_FALSE, undef_y.at(i));
680
681 undefGating(y, yy, undef_y);
682 }
683 return true;
684 }
685
686 if (cell->type == ID($lt) || cell->type == ID($le) || cell->type == ID($eq) || cell->type == ID($ne) || cell->type == ID($eqx) || cell->type == ID($nex) || cell->type == ID($ge) || cell->type == ID($gt))
687 {
688 bool is_signed = cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool();
689 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
690 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
691 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
692 extendSignalWidth(a, b, cell);
693
694 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
695
696 if (model_undef && (cell->type == ID($eqx) || cell->type == ID($nex))) {
697 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
698 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
699 extendSignalWidth(undef_a, undef_b, cell, true);
700 a = ez->vec_or(a, undef_a);
701 b = ez->vec_or(b, undef_b);
702 }
703
704 if (cell->type == ID($lt))
705 ez->SET(is_signed ? ez->vec_lt_signed(a, b) : ez->vec_lt_unsigned(a, b), yy.at(0));
706 if (cell->type == ID($le))
707 ez->SET(is_signed ? ez->vec_le_signed(a, b) : ez->vec_le_unsigned(a, b), yy.at(0));
708 if (cell->type == ID($eq) || cell->type == ID($eqx))
709 ez->SET(ez->vec_eq(a, b), yy.at(0));
710 if (cell->type == ID($ne) || cell->type == ID($nex))
711 ez->SET(ez->vec_ne(a, b), yy.at(0));
712 if (cell->type == ID($ge))
713 ez->SET(is_signed ? ez->vec_ge_signed(a, b) : ez->vec_ge_unsigned(a, b), yy.at(0));
714 if (cell->type == ID($gt))
715 ez->SET(is_signed ? ez->vec_gt_signed(a, b) : ez->vec_gt_unsigned(a, b), yy.at(0));
716 for (size_t i = 1; i < y.size(); i++)
717 ez->SET(ez->CONST_FALSE, yy.at(i));
718
719 if (model_undef && (cell->type == ID($eqx) || cell->type == ID($nex)))
720 {
721 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
722 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
723 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
724 extendSignalWidth(undef_a, undef_b, cell, true);
725
726 if (cell->type == ID($eqx))
727 yy.at(0) = ez->AND(yy.at(0), ez->vec_eq(undef_a, undef_b));
728 else
729 yy.at(0) = ez->OR(yy.at(0), ez->vec_ne(undef_a, undef_b));
730
731 for (size_t i = 0; i < y.size(); i++)
732 ez->SET(ez->CONST_FALSE, undef_y.at(i));
733
734 ez->assume(ez->vec_eq(y, yy));
735 }
736 else if (model_undef && (cell->type == ID($eq) || cell->type == ID($ne)))
737 {
738 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
739 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
740 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
741 extendSignalWidth(undef_a, undef_b, cell, true);
742
743 int undef_any_a = ez->expression(ezSAT::OpOr, undef_a);
744 int undef_any_b = ez->expression(ezSAT::OpOr, undef_b);
745 int undef_any = ez->OR(undef_any_a, undef_any_b);
746
747 std::vector<int> masked_a_bits = ez->vec_or(a, ez->vec_or(undef_a, undef_b));
748 std::vector<int> masked_b_bits = ez->vec_or(b, ez->vec_or(undef_a, undef_b));
749
750 int masked_ne = ez->vec_ne(masked_a_bits, masked_b_bits);
751 int undef_y_bit = ez->AND(undef_any, ez->NOT(masked_ne));
752
753 for (size_t i = 1; i < undef_y.size(); i++)
754 ez->SET(ez->CONST_FALSE, undef_y.at(i));
755 ez->SET(undef_y_bit, undef_y.at(0));
756
757 undefGating(y, yy, undef_y);
758 }
759 else
760 {
761 if (model_undef) {
762 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
763 undefGating(y, yy, undef_y);
764 }
765 log_assert(!model_undef || arith_undef_handled);
766 }
767 return true;
768 }
769
770 if (cell->type == ID($shl) || cell->type == ID($shr) || cell->type == ID($sshl) || cell->type == ID($sshr) || cell->type == ID($shift) || cell->type == ID($shiftx))
771 {
772 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
773 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
774 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
775
776 int extend_bit = ez->CONST_FALSE;
777
778 if (!cell->type.in(ID($shift), ID($shiftx)) && cell->parameters[ID(A_SIGNED)].as_bool())
779 extend_bit = a.back();
780
781 while (y.size() < a.size())
782 y.push_back(ez->literal());
783 while (y.size() > a.size())
784 a.push_back(extend_bit);
785
786 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
787 std::vector<int> shifted_a;
788
789 if (cell->type == ID($shl) || cell->type == ID($sshl))
790 shifted_a = ez->vec_shift_left(a, b, false, ez->CONST_FALSE, ez->CONST_FALSE);
791
792 if (cell->type == ID($shr))
793 shifted_a = ez->vec_shift_right(a, b, false, ez->CONST_FALSE, ez->CONST_FALSE);
794
795 if (cell->type == ID($sshr))
796 shifted_a = ez->vec_shift_right(a, b, false, cell->parameters[ID(A_SIGNED)].as_bool() ? a.back() : ez->CONST_FALSE, ez->CONST_FALSE);
797
798 if (cell->type == ID($shift) || cell->type == ID($shiftx))
799 shifted_a = ez->vec_shift_right(a, b, cell->parameters[ID(B_SIGNED)].as_bool(), ez->CONST_FALSE, ez->CONST_FALSE);
800
801 ez->assume(ez->vec_eq(shifted_a, yy));
802
803 if (model_undef)
804 {
805 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
806 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
807 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
808 std::vector<int> undef_a_shifted;
809
810 extend_bit = cell->type == ID($shiftx) ? ez->CONST_TRUE : ez->CONST_FALSE;
811 if (!cell->type.in(ID($shift), ID($shiftx)) && cell->parameters[ID(A_SIGNED)].as_bool())
812 extend_bit = undef_a.back();
813
814 while (undef_y.size() < undef_a.size())
815 undef_y.push_back(ez->literal());
816 while (undef_y.size() > undef_a.size())
817 undef_a.push_back(extend_bit);
818
819 if (cell->type == ID($shl) || cell->type == ID($sshl))
820 undef_a_shifted = ez->vec_shift_left(undef_a, b, false, ez->CONST_FALSE, ez->CONST_FALSE);
821
822 if (cell->type == ID($shr))
823 undef_a_shifted = ez->vec_shift_right(undef_a, b, false, ez->CONST_FALSE, ez->CONST_FALSE);
824
825 if (cell->type == ID($sshr))
826 undef_a_shifted = ez->vec_shift_right(undef_a, b, false, cell->parameters[ID(A_SIGNED)].as_bool() ? undef_a.back() : ez->CONST_FALSE, ez->CONST_FALSE);
827
828 if (cell->type == ID($shift))
829 undef_a_shifted = ez->vec_shift_right(undef_a, b, cell->parameters[ID(B_SIGNED)].as_bool(), ez->CONST_FALSE, ez->CONST_FALSE);
830
831 if (cell->type == ID($shiftx))
832 undef_a_shifted = ez->vec_shift_right(undef_a, b, cell->parameters[ID(B_SIGNED)].as_bool(), ez->CONST_TRUE, ez->CONST_TRUE);
833
834 int undef_any_b = ez->expression(ezSAT::OpOr, undef_b);
835 std::vector<int> undef_all_y_bits(undef_y.size(), undef_any_b);
836 ez->assume(ez->vec_eq(ez->vec_or(undef_a_shifted, undef_all_y_bits), undef_y));
837 undefGating(y, yy, undef_y);
838 }
839 return true;
840 }
841
842 if (cell->type == ID($mul))
843 {
844 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
845 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
846 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
847 extendSignalWidth(a, b, y, cell);
848
849 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
850
851 std::vector<int> tmp(a.size(), ez->CONST_FALSE);
852 for (int i = 0; i < int(a.size()); i++)
853 {
854 std::vector<int> shifted_a(a.size(), ez->CONST_FALSE);
855 for (int j = i; j < int(a.size()); j++)
856 shifted_a.at(j) = a.at(j-i);
857 tmp = ez->vec_ite(b.at(i), ez->vec_add(tmp, shifted_a), tmp);
858 }
859 ez->assume(ez->vec_eq(tmp, yy));
860
861 if (model_undef) {
862 log_assert(arith_undef_handled);
863 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
864 undefGating(y, yy, undef_y);
865 }
866 return true;
867 }
868
869 if (cell->type == ID($macc))
870 {
871 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
872 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
873 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
874
875 Macc macc;
876 macc.from_cell(cell);
877
878 std::vector<int> tmp(GetSize(y), ez->CONST_FALSE);
879
880 for (auto &port : macc.ports)
881 {
882 std::vector<int> in_a = importDefSigSpec(port.in_a, timestep);
883 std::vector<int> in_b = importDefSigSpec(port.in_b, timestep);
884
885 while (GetSize(in_a) < GetSize(y))
886 in_a.push_back(port.is_signed && !in_a.empty() ? in_a.back() : ez->CONST_FALSE);
887 in_a.resize(GetSize(y));
888
889 if (GetSize(in_b))
890 {
891 while (GetSize(in_b) < GetSize(y))
892 in_b.push_back(port.is_signed && !in_b.empty() ? in_b.back() : ez->CONST_FALSE);
893 in_b.resize(GetSize(y));
894
895 for (int i = 0; i < GetSize(in_b); i++) {
896 std::vector<int> shifted_a(in_a.size(), ez->CONST_FALSE);
897 for (int j = i; j < int(in_a.size()); j++)
898 shifted_a.at(j) = in_a.at(j-i);
899 if (port.do_subtract)
900 tmp = ez->vec_ite(in_b.at(i), ez->vec_sub(tmp, shifted_a), tmp);
901 else
902 tmp = ez->vec_ite(in_b.at(i), ez->vec_add(tmp, shifted_a), tmp);
903 }
904 }
905 else
906 {
907 if (port.do_subtract)
908 tmp = ez->vec_sub(tmp, in_a);
909 else
910 tmp = ez->vec_add(tmp, in_a);
911 }
912 }
913
914 for (int i = 0; i < GetSize(b); i++) {
915 std::vector<int> val(GetSize(y), ez->CONST_FALSE);
916 val.at(0) = b.at(i);
917 tmp = ez->vec_add(tmp, val);
918 }
919
920 if (model_undef)
921 {
922 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
923 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
924
925 int undef_any_a = ez->expression(ezSAT::OpOr, undef_a);
926 int undef_any_b = ez->expression(ezSAT::OpOr, undef_b);
927
928 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
929 ez->assume(ez->vec_eq(undef_y, std::vector<int>(GetSize(y), ez->OR(undef_any_a, undef_any_b))));
930
931 undefGating(y, tmp, undef_y);
932 }
933 else
934 ez->assume(ez->vec_eq(y, tmp));
935
936 return true;
937 }
938
939 if (cell->type == ID($div) || cell->type == ID($mod))
940 {
941 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
942 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
943 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
944 extendSignalWidth(a, b, y, cell);
945
946 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
947
948 std::vector<int> a_u, b_u;
949 if (cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool()) {
950 a_u = ez->vec_ite(a.back(), ez->vec_neg(a), a);
951 b_u = ez->vec_ite(b.back(), ez->vec_neg(b), b);
952 } else {
953 a_u = a;
954 b_u = b;
955 }
956
957 std::vector<int> chain_buf = a_u;
958 std::vector<int> y_u(a_u.size(), ez->CONST_FALSE);
959 for (int i = int(a.size())-1; i >= 0; i--)
960 {
961 chain_buf.insert(chain_buf.end(), chain_buf.size(), ez->CONST_FALSE);
962
963 std::vector<int> b_shl(i, ez->CONST_FALSE);
964 b_shl.insert(b_shl.end(), b_u.begin(), b_u.end());
965 b_shl.insert(b_shl.end(), chain_buf.size()-b_shl.size(), ez->CONST_FALSE);
966
967 y_u.at(i) = ez->vec_ge_unsigned(chain_buf, b_shl);
968 chain_buf = ez->vec_ite(y_u.at(i), ez->vec_sub(chain_buf, b_shl), chain_buf);
969
970 chain_buf.erase(chain_buf.begin() + a_u.size(), chain_buf.end());
971 }
972
973 std::vector<int> y_tmp = ignore_div_by_zero ? yy : ez->vec_var(y.size());
974 if (cell->type == ID($div)) {
975 if (cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool())
976 ez->assume(ez->vec_eq(y_tmp, ez->vec_ite(ez->XOR(a.back(), b.back()), ez->vec_neg(y_u), y_u)));
977 else
978 ez->assume(ez->vec_eq(y_tmp, y_u));
979 } else {
980 if (cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool())
981 ez->assume(ez->vec_eq(y_tmp, ez->vec_ite(a.back(), ez->vec_neg(chain_buf), chain_buf)));
982 else
983 ez->assume(ez->vec_eq(y_tmp, chain_buf));
984 }
985
986 if (ignore_div_by_zero) {
987 ez->assume(ez->expression(ezSAT::OpOr, b));
988 } else {
989 std::vector<int> div_zero_result;
990 if (cell->type == ID($div)) {
991 if (cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool()) {
992 std::vector<int> all_ones(y.size(), ez->CONST_TRUE);
993 std::vector<int> only_first_one(y.size(), ez->CONST_FALSE);
994 only_first_one.at(0) = ez->CONST_TRUE;
995 div_zero_result = ez->vec_ite(a.back(), only_first_one, all_ones);
996 } else {
997 div_zero_result.insert(div_zero_result.end(), cell->getPort(ID(A)).size(), ez->CONST_TRUE);
998 div_zero_result.insert(div_zero_result.end(), y.size() - div_zero_result.size(), ez->CONST_FALSE);
999 }
1000 } else {
1001 int copy_a_bits = min(cell->getPort(ID(A)).size(), cell->getPort(ID(B)).size());
1002 div_zero_result.insert(div_zero_result.end(), a.begin(), a.begin() + copy_a_bits);
1003 if (cell->parameters[ID(A_SIGNED)].as_bool() && cell->parameters[ID(B_SIGNED)].as_bool())
1004 div_zero_result.insert(div_zero_result.end(), y.size() - div_zero_result.size(), div_zero_result.back());
1005 else
1006 div_zero_result.insert(div_zero_result.end(), y.size() - div_zero_result.size(), ez->CONST_FALSE);
1007 }
1008 ez->assume(ez->vec_eq(yy, ez->vec_ite(ez->expression(ezSAT::OpOr, b), y_tmp, div_zero_result)));
1009 }
1010
1011 if (model_undef) {
1012 log_assert(arith_undef_handled);
1013 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1014 undefGating(y, yy, undef_y);
1015 }
1016 return true;
1017 }
1018
1019 if (cell->type == ID($lut))
1020 {
1021 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
1022 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1023
1024 std::vector<int> lut;
1025 for (auto bit : cell->getParam(ID(LUT)).bits)
1026 lut.push_back(bit == State::S1 ? ez->CONST_TRUE : ez->CONST_FALSE);
1027 while (GetSize(lut) < (1 << GetSize(a)))
1028 lut.push_back(ez->CONST_FALSE);
1029 lut.resize(1 << GetSize(a));
1030
1031 if (model_undef)
1032 {
1033 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
1034 std::vector<int> t(lut), u(GetSize(t), ez->CONST_FALSE);
1035
1036 for (int i = GetSize(a)-1; i >= 0; i--)
1037 {
1038 std::vector<int> t0(t.begin(), t.begin() + GetSize(t)/2);
1039 std::vector<int> t1(t.begin() + GetSize(t)/2, t.end());
1040
1041 std::vector<int> u0(u.begin(), u.begin() + GetSize(u)/2);
1042 std::vector<int> u1(u.begin() + GetSize(u)/2, u.end());
1043
1044 t = ez->vec_ite(a[i], t1, t0);
1045 u = ez->vec_ite(undef_a[i], ez->vec_or(ez->vec_xor(t0, t1), ez->vec_or(u0, u1)), ez->vec_ite(a[i], u1, u0));
1046 }
1047
1048 log_assert(GetSize(t) == 1);
1049 log_assert(GetSize(u) == 1);
1050 undefGating(y, t, u);
1051 ez->assume(ez->vec_eq(importUndefSigSpec(cell->getPort(ID(Y)), timestep), u));
1052 }
1053 else
1054 {
1055 std::vector<int> t = lut;
1056 for (int i = GetSize(a)-1; i >= 0; i--)
1057 {
1058 std::vector<int> t0(t.begin(), t.begin() + GetSize(t)/2);
1059 std::vector<int> t1(t.begin() + GetSize(t)/2, t.end());
1060 t = ez->vec_ite(a[i], t1, t0);
1061 }
1062
1063 log_assert(GetSize(t) == 1);
1064 ez->assume(ez->vec_eq(y, t));
1065 }
1066 return true;
1067 }
1068
1069 if (cell->type == ID($sop))
1070 {
1071 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
1072 int y = importDefSigSpec(cell->getPort(ID(Y)), timestep).at(0);
1073
1074 int width = cell->getParam(ID(WIDTH)).as_int();
1075 int depth = cell->getParam(ID(DEPTH)).as_int();
1076
1077 vector<State> table_raw = cell->getParam(ID(TABLE)).bits;
1078 while (GetSize(table_raw) < 2*width*depth)
1079 table_raw.push_back(State::S0);
1080
1081 vector<vector<int>> table(depth);
1082
1083 for (int i = 0; i < depth; i++)
1084 for (int j = 0; j < width; j++)
1085 {
1086 bool pat0 = (table_raw[2*width*i + 2*j + 0] == State::S1);
1087 bool pat1 = (table_raw[2*width*i + 2*j + 1] == State::S1);
1088
1089 if (pat0 && !pat1)
1090 table.at(i).push_back(0);
1091 else if (!pat0 && pat1)
1092 table.at(i).push_back(1);
1093 else
1094 table.at(i).push_back(-1);
1095 }
1096
1097 if (model_undef)
1098 {
1099 std::vector<int> products, undef_products;
1100 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
1101 int undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep).at(0);
1102
1103 for (int i = 0; i < depth; i++)
1104 {
1105 std::vector<int> cmp_a, cmp_ua, cmp_b;
1106
1107 for (int j = 0; j < width; j++)
1108 if (table.at(i).at(j) >= 0) {
1109 cmp_a.push_back(a.at(j));
1110 cmp_ua.push_back(undef_a.at(j));
1111 cmp_b.push_back(table.at(i).at(j) ? ez->CONST_TRUE : ez->CONST_FALSE);
1112 }
1113
1114 std::vector<int> masked_a = ez->vec_or(cmp_a, cmp_ua);
1115 std::vector<int> masked_b = ez->vec_or(cmp_b, cmp_ua);
1116
1117 int masked_eq = ez->vec_eq(masked_a, masked_b);
1118 int any_undef = ez->expression(ezSAT::OpOr, cmp_ua);
1119
1120 undef_products.push_back(ez->AND(any_undef, masked_eq));
1121 products.push_back(ez->AND(ez->NOT(any_undef), masked_eq));
1122 }
1123
1124 int yy = ez->expression(ezSAT::OpOr, products);
1125 ez->SET(undef_y, ez->AND(ez->NOT(yy), ez->expression(ezSAT::OpOr, undef_products)));
1126 undefGating(y, yy, undef_y);
1127 }
1128 else
1129 {
1130 std::vector<int> products;
1131
1132 for (int i = 0; i < depth; i++)
1133 {
1134 std::vector<int> cmp_a, cmp_b;
1135
1136 for (int j = 0; j < width; j++)
1137 if (table.at(i).at(j) >= 0) {
1138 cmp_a.push_back(a.at(j));
1139 cmp_b.push_back(table.at(i).at(j) ? ez->CONST_TRUE : ez->CONST_FALSE);
1140 }
1141
1142 products.push_back(ez->vec_eq(cmp_a, cmp_b));
1143 }
1144
1145 ez->SET(y, ez->expression(ezSAT::OpOr, products));
1146 }
1147
1148 return true;
1149 }
1150
1151 if (cell->type == ID($fa))
1152 {
1153 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
1154 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
1155 std::vector<int> c = importDefSigSpec(cell->getPort(ID(C)), timestep);
1156 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1157 std::vector<int> x = importDefSigSpec(cell->getPort(ID(X)), timestep);
1158
1159 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
1160 std::vector<int> xx = model_undef ? ez->vec_var(x.size()) : x;
1161
1162 std::vector<int> t1 = ez->vec_xor(a, b);
1163 ez->assume(ez->vec_eq(yy, ez->vec_xor(t1, c)));
1164
1165 std::vector<int> t2 = ez->vec_and(a, b);
1166 std::vector<int> t3 = ez->vec_and(c, t1);
1167 ez->assume(ez->vec_eq(xx, ez->vec_or(t2, t3)));
1168
1169 if (model_undef)
1170 {
1171 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
1172 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
1173 std::vector<int> undef_c = importUndefSigSpec(cell->getPort(ID(C)), timestep);
1174
1175 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1176 std::vector<int> undef_x = importUndefSigSpec(cell->getPort(ID(X)), timestep);
1177
1178 ez->assume(ez->vec_eq(undef_y, ez->vec_or(ez->vec_or(undef_a, undef_b), undef_c)));
1179 ez->assume(ez->vec_eq(undef_x, undef_y));
1180
1181 undefGating(y, yy, undef_y);
1182 undefGating(x, xx, undef_x);
1183 }
1184 return true;
1185 }
1186
1187 if (cell->type == ID($lcu))
1188 {
1189 std::vector<int> p = importDefSigSpec(cell->getPort(ID(P)), timestep);
1190 std::vector<int> g = importDefSigSpec(cell->getPort(ID(G)), timestep);
1191 std::vector<int> ci = importDefSigSpec(cell->getPort(ID(CI)), timestep);
1192 std::vector<int> co = importDefSigSpec(cell->getPort(ID(CO)), timestep);
1193
1194 std::vector<int> yy = model_undef ? ez->vec_var(co.size()) : co;
1195
1196 for (int i = 0; i < GetSize(co); i++)
1197 ez->SET(yy[i], ez->OR(g[i], ez->AND(p[i], i ? yy[i-1] : ci[0])));
1198
1199 if (model_undef)
1200 {
1201 std::vector<int> undef_p = importUndefSigSpec(cell->getPort(ID(P)), timestep);
1202 std::vector<int> undef_g = importUndefSigSpec(cell->getPort(ID(G)), timestep);
1203 std::vector<int> undef_ci = importUndefSigSpec(cell->getPort(ID(CI)), timestep);
1204 std::vector<int> undef_co = importUndefSigSpec(cell->getPort(ID(CO)), timestep);
1205
1206 int undef_any_p = ez->expression(ezSAT::OpOr, undef_p);
1207 int undef_any_g = ez->expression(ezSAT::OpOr, undef_g);
1208 int undef_any_ci = ez->expression(ezSAT::OpOr, undef_ci);
1209 int undef_co_bit = ez->OR(undef_any_p, undef_any_g, undef_any_ci);
1210
1211 std::vector<int> undef_co_bits(undef_co.size(), undef_co_bit);
1212 ez->assume(ez->vec_eq(undef_co_bits, undef_co));
1213
1214 undefGating(co, yy, undef_co);
1215 }
1216 return true;
1217 }
1218
1219 if (cell->type == ID($alu))
1220 {
1221 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
1222 std::vector<int> b = importDefSigSpec(cell->getPort(ID(B)), timestep);
1223 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1224 std::vector<int> x = importDefSigSpec(cell->getPort(ID(X)), timestep);
1225 std::vector<int> ci = importDefSigSpec(cell->getPort(ID(CI)), timestep);
1226 std::vector<int> bi = importDefSigSpec(cell->getPort(ID(BI)), timestep);
1227 std::vector<int> co = importDefSigSpec(cell->getPort(ID(CO)), timestep);
1228
1229 extendSignalWidth(a, b, y, cell);
1230 extendSignalWidth(a, b, x, cell);
1231 extendSignalWidth(a, b, co, cell);
1232
1233 std::vector<int> def_y = model_undef ? ez->vec_var(y.size()) : y;
1234 std::vector<int> def_x = model_undef ? ez->vec_var(x.size()) : x;
1235 std::vector<int> def_co = model_undef ? ez->vec_var(co.size()) : co;
1236
1237 log_assert(GetSize(y) == GetSize(x));
1238 log_assert(GetSize(y) == GetSize(co));
1239 log_assert(GetSize(ci) == 1);
1240 log_assert(GetSize(bi) == 1);
1241
1242 for (int i = 0; i < GetSize(y); i++)
1243 {
1244 int s1 = a.at(i), s2 = ez->XOR(b.at(i), bi.at(0)), s3 = i ? co.at(i-1) : ci.at(0);
1245 ez->SET(def_x.at(i), ez->XOR(s1, s2));
1246 ez->SET(def_y.at(i), ez->XOR(def_x.at(i), s3));
1247 ez->SET(def_co.at(i), ez->OR(ez->AND(s1, s2), ez->AND(s1, s3), ez->AND(s2, s3)));
1248 }
1249
1250 if (model_undef)
1251 {
1252 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
1253 std::vector<int> undef_b = importUndefSigSpec(cell->getPort(ID(B)), timestep);
1254 std::vector<int> undef_ci = importUndefSigSpec(cell->getPort(ID(CI)), timestep);
1255 std::vector<int> undef_bi = importUndefSigSpec(cell->getPort(ID(BI)), timestep);
1256
1257 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1258 std::vector<int> undef_x = importUndefSigSpec(cell->getPort(ID(X)), timestep);
1259 std::vector<int> undef_co = importUndefSigSpec(cell->getPort(ID(CO)), timestep);
1260
1261 extendSignalWidth(undef_a, undef_b, undef_y, cell);
1262 extendSignalWidth(undef_a, undef_b, undef_x, cell);
1263 extendSignalWidth(undef_a, undef_b, undef_co, cell);
1264
1265 std::vector<int> all_inputs_undef;
1266 all_inputs_undef.insert(all_inputs_undef.end(), undef_a.begin(), undef_a.end());
1267 all_inputs_undef.insert(all_inputs_undef.end(), undef_b.begin(), undef_b.end());
1268 all_inputs_undef.insert(all_inputs_undef.end(), undef_ci.begin(), undef_ci.end());
1269 all_inputs_undef.insert(all_inputs_undef.end(), undef_bi.begin(), undef_bi.end());
1270 int undef_any = ez->expression(ezSAT::OpOr, all_inputs_undef);
1271
1272 for (int i = 0; i < GetSize(undef_y); i++) {
1273 ez->SET(undef_y.at(i), undef_any);
1274 ez->SET(undef_x.at(i), ez->OR(undef_a.at(i), undef_b.at(i), undef_bi.at(0)));
1275 ez->SET(undef_co.at(i), undef_any);
1276 }
1277
1278 undefGating(y, def_y, undef_y);
1279 undefGating(x, def_x, undef_x);
1280 undefGating(co, def_co, undef_co);
1281 }
1282 return true;
1283 }
1284
1285 if (cell->type == ID($slice))
1286 {
1287 RTLIL::SigSpec a = cell->getPort(ID(A));
1288 RTLIL::SigSpec y = cell->getPort(ID(Y));
1289 ez->assume(signals_eq(a.extract(cell->parameters.at(ID(OFFSET)).as_int(), y.size()), y, timestep));
1290 return true;
1291 }
1292
1293 if (cell->type == ID($concat))
1294 {
1295 RTLIL::SigSpec a = cell->getPort(ID(A));
1296 RTLIL::SigSpec b = cell->getPort(ID(B));
1297 RTLIL::SigSpec y = cell->getPort(ID(Y));
1298
1299 RTLIL::SigSpec ab = a;
1300 ab.append(b);
1301
1302 ez->assume(signals_eq(ab, y, timestep));
1303 return true;
1304 }
1305
1306 if (timestep > 0 && cell->type.in(ID($ff), ID($dff), ID($_FF_), ID($_DFF_N_), ID($_DFF_P_)))
1307 {
1308 if (timestep == 1)
1309 {
1310 initial_state.add((*sigmap)(cell->getPort(ID(Q))));
1311 }
1312 else
1313 {
1314 std::vector<int> d = importDefSigSpec(cell->getPort(ID(D)), timestep-1);
1315 std::vector<int> q = importDefSigSpec(cell->getPort(ID(Q)), timestep);
1316
1317 std::vector<int> qq = model_undef ? ez->vec_var(q.size()) : q;
1318 ez->assume(ez->vec_eq(d, qq));
1319
1320 if (model_undef)
1321 {
1322 std::vector<int> undef_d = importUndefSigSpec(cell->getPort(ID(D)), timestep-1);
1323 std::vector<int> undef_q = importUndefSigSpec(cell->getPort(ID(Q)), timestep);
1324
1325 ez->assume(ez->vec_eq(undef_d, undef_q));
1326 undefGating(q, qq, undef_q);
1327 }
1328 }
1329 return true;
1330 }
1331
1332 if (cell->type == ID($anyconst))
1333 {
1334 if (timestep < 2)
1335 return true;
1336
1337 std::vector<int> d = importDefSigSpec(cell->getPort(ID(Y)), timestep-1);
1338 std::vector<int> q = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1339
1340 std::vector<int> qq = model_undef ? ez->vec_var(q.size()) : q;
1341 ez->assume(ez->vec_eq(d, qq));
1342
1343 if (model_undef)
1344 {
1345 std::vector<int> undef_d = importUndefSigSpec(cell->getPort(ID(Y)), timestep-1);
1346 std::vector<int> undef_q = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1347
1348 ez->assume(ez->vec_eq(undef_d, undef_q));
1349 undefGating(q, qq, undef_q);
1350 }
1351 return true;
1352 }
1353
1354 if (cell->type == ID($anyseq))
1355 {
1356 return true;
1357 }
1358
1359 if (cell->type == ID($_BUF_) || cell->type == ID($equiv))
1360 {
1361 std::vector<int> a = importDefSigSpec(cell->getPort(ID(A)), timestep);
1362 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1363 extendSignalWidthUnary(a, y, cell);
1364
1365 std::vector<int> yy = model_undef ? ez->vec_var(y.size()) : y;
1366 ez->assume(ez->vec_eq(a, yy));
1367
1368 if (model_undef) {
1369 std::vector<int> undef_a = importUndefSigSpec(cell->getPort(ID(A)), timestep);
1370 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1371 extendSignalWidthUnary(undef_a, undef_y, cell, false);
1372 ez->assume(ez->vec_eq(undef_a, undef_y));
1373 undefGating(y, yy, undef_y);
1374 }
1375 return true;
1376 }
1377
1378 if (cell->type == ID($initstate))
1379 {
1380 auto key = make_pair(prefix, timestep);
1381 if (initstates.count(key) == 0)
1382 initstates[key] = false;
1383
1384 std::vector<int> y = importDefSigSpec(cell->getPort(ID(Y)), timestep);
1385 log_assert(GetSize(y) == 1);
1386 ez->SET(y[0], initstates[key] ? ez->CONST_TRUE : ez->CONST_FALSE);
1387
1388 if (model_undef) {
1389 std::vector<int> undef_y = importUndefSigSpec(cell->getPort(ID(Y)), timestep);
1390 log_assert(GetSize(undef_y) == 1);
1391 ez->SET(undef_y[0], ez->CONST_FALSE);
1392 }
1393
1394 return true;
1395 }
1396
1397 if (cell->type == ID($assert))
1398 {
1399 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
1400 asserts_a[pf].append((*sigmap)(cell->getPort(ID(A))));
1401 asserts_en[pf].append((*sigmap)(cell->getPort(ID(EN))));
1402 return true;
1403 }
1404
1405 if (cell->type == ID($assume))
1406 {
1407 std::string pf = prefix + (timestep == -1 ? "" : stringf("@%d:", timestep));
1408 assumes_a[pf].append((*sigmap)(cell->getPort(ID(A))));
1409 assumes_en[pf].append((*sigmap)(cell->getPort(ID(EN))));
1410 return true;
1411 }
1412
1413 // Unsupported internal cell types: $pow $lut
1414 // .. and all sequential cells except $dff and $_DFF_[NP]_
1415 return false;
1416 }
1417 };
1418
1419 YOSYS_NAMESPACE_END
1420
1421 #endif