projects / yosys.git / blob
? search:


9c431ab25692d03eab7e3d422f291b8f36dc948f
[yosys.git] / passes / sat / sim.cc
1 /*
2 * yosys -- Yosys Open SYnthesis Suite
3 *
4 * Copyright (C) 2012 Claire Xenia Wolf <claire@yosyshq.com>
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 #include "kernel/yosys.h"
21 #include "kernel/sigtools.h"
22 #include "kernel/celltypes.h"
23 #include "kernel/mem.h"
24 #include "kernel/fstdata.h"
25 #include "kernel/ff.h"
26
27 #include <ctime>
28
29 USING_YOSYS_NAMESPACE
30 PRIVATE_NAMESPACE_BEGIN
31
32 enum class SimulationMode {
33 sim,
34 cmp,
35 gold,
36 gate,
37 };
38
39 static const std::map<std::string, int> g_units =
40 {
41 { "", -9 }, // default is ns
42 { "s", 0 },
43 { "ms", -3 },
44 { "us", -6 },
45 { "ns", -9 },
46 { "ps", -12 },
47 { "fs", -15 },
48 { "as", -18 },
49 { "zs", -21 },
50 };
51
52 static double stringToTime(std::string str)
53 {
54 if (str=="END") return -1;
55
56 char *endptr;
57 long value = strtol(str.c_str(), &endptr, 10);
58
59 if (g_units.find(endptr)==g_units.end())
60 log_error("Cannot parse '%s', bad unit '%s'\n", str.c_str(), endptr);
61
62 if (value < 0)
63 log_error("Time value '%s' must be positive\n", str.c_str());
64
65 return value * pow(10.0, g_units.at(endptr));
66 }
67
68 struct SimWorker;
69 struct OutputWriter
70 {
71 OutputWriter(SimWorker *w) { worker = w;};
72 virtual ~OutputWriter() {};
73 virtual void write(std::map<int, bool> &use_signal) = 0;
74 SimWorker *worker;
75 };
76
77 struct SimShared
78 {
79 bool debug = false;
80 bool verbose = true;
81 bool hide_internal = true;
82 bool writeback = false;
83 bool zinit = false;
84 int rstlen = 1;
85 FstData *fst = nullptr;
86 double start_time = 0;
87 double stop_time = -1;
88 SimulationMode sim_mode = SimulationMode::sim;
89 bool cycles_set = false;
90 std::vector<std::unique_ptr<OutputWriter>> outputfiles;
91 std::vector<std::pair<int,std::map<int,Const>>> output_data;
92 bool ignore_x = false;
93 bool date = false;
94 bool multiclock = false;
95 };
96
97 void zinit(State &v)
98 {
99 if (v != State::S1)
100 v = State::S0;
101 }
102
103 void zinit(Const &v)
104 {
105 for (auto &bit : v.bits)
106 zinit(bit);
107 }
108
109 struct SimInstance
110 {
111 SimShared *shared;
112
113 std::string scope;
114 Module *module;
115 Cell *instance;
116
117 SimInstance *parent;
118 dict<Cell*, SimInstance*> children;
119
120 SigMap sigmap;
121 dict<SigBit, State> state_nets;
122 dict<SigBit, pool<Cell*>> upd_cells;
123 dict<SigBit, pool<Wire*>> upd_outports;
124
125 pool<SigBit> dirty_bits;
126 pool<Cell*> dirty_cells;
127 pool<IdString> dirty_memories;
128 pool<SimInstance*, hash_ptr_ops> dirty_children;
129
130 struct ff_state_t
131 {
132 Const past_d;
133 Const past_ad;
134 State past_clk;
135 State past_ce;
136 State past_srst;
137
138 FfData data;
139 };
140
141 struct mem_state_t
142 {
143 Mem *mem;
144 std::vector<Const> past_wr_clk;
145 std::vector<Const> past_wr_en;
146 std::vector<Const> past_wr_addr;
147 std::vector<Const> past_wr_data;
148 Const data;
149 };
150
151 dict<Cell*, ff_state_t> ff_database;
152 dict<IdString, mem_state_t> mem_database;
153 pool<Cell*> formal_database;
154 dict<Cell*, IdString> mem_cells;
155
156 std::vector<Mem> memories;
157
158 dict<Wire*, pair<int, Const>> signal_database;
159 dict<Wire*, fstHandle> fst_handles;
160
161 SimInstance(SimShared *shared, std::string scope, Module *module, Cell *instance = nullptr, SimInstance *parent = nullptr) :
162 shared(shared), scope(scope), module(module), instance(instance), parent(parent), sigmap(module)
163 {
164 log_assert(module);
165
166 if (parent) {
167 log_assert(parent->children.count(instance) == 0);
168 parent->children[instance] = this;
169 }
170
171 for (auto wire : module->wires())
172 {
173 SigSpec sig = sigmap(wire);
174
175 for (int i = 0; i < GetSize(sig); i++) {
176 if (state_nets.count(sig[i]) == 0)
177 state_nets[sig[i]] = State::Sx;
178 if (wire->port_output) {
179 upd_outports[sig[i]].insert(wire);
180 dirty_bits.insert(sig[i]);
181 }
182 }
183
184 if ((shared->fst) && !(shared->hide_internal && wire->name[0] == '$')) {
185 fstHandle id = shared->fst->getHandle(scope + "." + RTLIL::unescape_id(wire->name));
186 if (id==0 && wire->name.isPublic())
187 log_warning("Unable to find wire %s in input file.\n", (scope + "." + RTLIL::unescape_id(wire->name)).c_str());
188 fst_handles[wire] = id;
189 }
190
191 if (wire->attributes.count(ID::init)) {
192 Const initval = wire->attributes.at(ID::init);
193 for (int i = 0; i < GetSize(sig) && i < GetSize(initval); i++)
194 if (initval[i] == State::S0 || initval[i] == State::S1) {
195 state_nets[sig[i]] = initval[i];
196 dirty_bits.insert(sig[i]);
197 }
198 }
199 }
200
201 memories = Mem::get_all_memories(module);
202 for (auto &mem : memories) {
203 auto &mdb = mem_database[mem.memid];
204 mdb.mem = &mem;
205 for (auto &port : mem.wr_ports) {
206 mdb.past_wr_clk.push_back(Const(State::Sx));
207 mdb.past_wr_en.push_back(Const(State::Sx, GetSize(port.en)));
208 mdb.past_wr_addr.push_back(Const(State::Sx, GetSize(port.addr)));
209 mdb.past_wr_data.push_back(Const(State::Sx, GetSize(port.data)));
210 }
211 mdb.data = mem.get_init_data();
212 }
213
214 for (auto cell : module->cells())
215 {
216 Module *mod = module->design->module(cell->type);
217
218 if (mod != nullptr) {
219 dirty_children.insert(new SimInstance(shared, scope + "." + RTLIL::unescape_id(cell->name), mod, cell, this));
220 }
221
222 for (auto &port : cell->connections()) {
223 if (cell->input(port.first))
224 for (auto bit : sigmap(port.second)) {
225 upd_cells[bit].insert(cell);
226 // Make sure cell inputs connected to constants are updated in the first cycle
227 if (bit.wire == nullptr)
228 dirty_bits.insert(bit);
229 }
230 }
231
232 if (RTLIL::builtin_ff_cell_types().count(cell->type)) {
233 FfData ff_data(nullptr, cell);
234 ff_state_t ff;
235 ff.past_d = Const(State::Sx, ff_data.width);
236 ff.past_ad = Const(State::Sx, ff_data.width);
237 ff.past_clk = State::Sx;
238 ff.past_ce = State::Sx;
239 ff.past_srst = State::Sx;
240 ff.data = ff_data;
241 ff_database[cell] = ff;
242 }
243
244 if (cell->is_mem_cell())
245 {
246 mem_cells[cell] = cell->parameters.at(ID::MEMID).decode_string();
247 }
248 if (cell->type.in(ID($assert), ID($cover), ID($assume))) {
249 formal_database.insert(cell);
250 }
251 }
252
253 if (shared->zinit)
254 {
255 for (auto &it : ff_database)
256 {
257 ff_state_t &ff = it.second;
258 zinit(ff.past_d);
259 zinit(ff.past_ad);
260
261 SigSpec qsig = it.second.data.sig_q;
262 Const qdata = get_state(qsig);
263 zinit(qdata);
264 set_state(qsig, qdata);
265 }
266
267 for (auto &it : mem_database) {
268 mem_state_t &mem = it.second;
269 for (auto &val : mem.past_wr_en)
270 zinit(val);
271 zinit(mem.data);
272 }
273 }
274 }
275
276 ~SimInstance()
277 {
278 for (auto child : children)
279 delete child.second;
280 }
281
282 IdString name() const
283 {
284 if (instance != nullptr)
285 return instance->name;
286 return module->name;
287 }
288
289 std::string hiername() const
290 {
291 if (instance != nullptr)
292 return parent->hiername() + "." + log_id(instance->name);
293
294 return log_id(module->name);
295 }
296
297 Const get_state(SigSpec sig)
298 {
299 Const value;
300
301 for (auto bit : sigmap(sig))
302 if (bit.wire == nullptr)
303 value.bits.push_back(bit.data);
304 else if (state_nets.count(bit))
305 value.bits.push_back(state_nets.at(bit));
306 else
307 value.bits.push_back(State::Sz);
308
309 if (shared->debug)
310 log("[%s] get %s: %s\n", hiername().c_str(), log_signal(sig), log_signal(value));
311 return value;
312 }
313
314 bool set_state(SigSpec sig, Const value)
315 {
316 bool did_something = false;
317
318 sig = sigmap(sig);
319 log_assert(GetSize(sig) <= GetSize(value));
320
321 for (int i = 0; i < GetSize(sig); i++)
322 if (state_nets.at(sig[i]) != value[i]) {
323 state_nets.at(sig[i]) = value[i];
324 dirty_bits.insert(sig[i]);
325 did_something = true;
326 }
327
328 if (shared->debug)
329 log("[%s] set %s: %s\n", hiername().c_str(), log_signal(sig), log_signal(value));
330 return did_something;
331 }
332
333 void set_memory_state(IdString memid, Const addr, Const data)
334 {
335 auto &state = mem_database[memid];
336
337 int offset = (addr.as_int() - state.mem->start_offset) * state.mem->width;
338 for (int i = 0; i < GetSize(data); i++)
339 if (0 <= i+offset && i+offset < GetSize(data))
340 state.data.bits[i+offset] = data.bits[i];
341 }
342
343 void set_memory_state_bit(IdString memid, int offset, State data)
344 {
345 auto &state = mem_database[memid];
346 if (offset >= state.mem->size * state.mem->width)
347 log_error("Addressing out of bounds bit %d/%d of memory %s\n", offset, state.mem->size * state.mem->width, log_id(memid));
348 state.data.bits[offset] = data;
349 }
350
351 void update_cell(Cell *cell)
352 {
353 if (ff_database.count(cell))
354 return;
355
356 if (formal_database.count(cell))
357 return;
358
359 if (mem_cells.count(cell))
360 {
361 dirty_memories.insert(mem_cells[cell]);
362 return;
363 }
364
365 if (children.count(cell))
366 {
367 auto child = children.at(cell);
368 for (auto &conn: cell->connections())
369 if (cell->input(conn.first) && GetSize(conn.second)) {
370 Const value = get_state(conn.second);
371 child->set_state(child->module->wire(conn.first), value);
372 }
373 dirty_children.insert(child);
374 return;
375 }
376
377 if (yosys_celltypes.cell_evaluable(cell->type))
378 {
379 RTLIL::SigSpec sig_a, sig_b, sig_c, sig_d, sig_s, sig_y;
380 bool has_a, has_b, has_c, has_d, has_s, has_y;
381
382 has_a = cell->hasPort(ID::A);
383 has_b = cell->hasPort(ID::B);
384 has_c = cell->hasPort(ID::C);
385 has_d = cell->hasPort(ID::D);
386 has_s = cell->hasPort(ID::S);
387 has_y = cell->hasPort(ID::Y);
388
389 if (has_a) sig_a = cell->getPort(ID::A);
390 if (has_b) sig_b = cell->getPort(ID::B);
391 if (has_c) sig_c = cell->getPort(ID::C);
392 if (has_d) sig_d = cell->getPort(ID::D);
393 if (has_s) sig_s = cell->getPort(ID::S);
394 if (has_y) sig_y = cell->getPort(ID::Y);
395
396 if (shared->debug)
397 log("[%s] eval %s (%s)\n", hiername().c_str(), log_id(cell), log_id(cell->type));
398
399 // Simple (A -> Y) and (A,B -> Y) cells
400 if (has_a && !has_c && !has_d && !has_s && has_y) {
401 set_state(sig_y, CellTypes::eval(cell, get_state(sig_a), get_state(sig_b)));
402 return;
403 }
404
405 // (A,B,C -> Y) cells
406 if (has_a && has_b && has_c && !has_d && !has_s && has_y) {
407 set_state(sig_y, CellTypes::eval(cell, get_state(sig_a), get_state(sig_b), get_state(sig_c)));
408 return;
409 }
410
411 // (A,S -> Y) cells
412 if (has_a && !has_b && !has_c && !has_d && has_s && has_y) {
413 set_state(sig_y, CellTypes::eval(cell, get_state(sig_a), get_state(sig_s)));
414 return;
415 }
416
417 // (A,B,S -> Y) cells
418 if (has_a && has_b && !has_c && !has_d && has_s && has_y) {
419 set_state(sig_y, CellTypes::eval(cell, get_state(sig_a), get_state(sig_b), get_state(sig_s)));
420 return;
421 }
422
423 log_warning("Unsupported evaluable cell type: %s (%s.%s)\n", log_id(cell->type), log_id(module), log_id(cell));
424 return;
425 }
426
427 log_error("Unsupported cell type: %s (%s.%s)\n", log_id(cell->type), log_id(module), log_id(cell));
428 }
429
430 void update_memory(IdString id) {
431 auto &mdb = mem_database[id];
432 auto &mem = *mdb.mem;
433
434 for (int port_idx = 0; port_idx < GetSize(mem.rd_ports); port_idx++)
435 {
436 auto &port = mem.rd_ports[port_idx];
437 Const addr = get_state(port.addr);
438 Const data = Const(State::Sx, mem.width << port.wide_log2);
439
440 if (port.clk_enable)
441 log_error("Memory %s.%s has clocked read ports. Run 'memory' with -nordff.\n", log_id(module), log_id(mem.memid));
442
443 if (addr.is_fully_def()) {
444 int index = addr.as_int() - mem.start_offset;
445 if (index >= 0 && index < mem.size)
446 data = mdb.data.extract(index*mem.width, mem.width << port.wide_log2);
447 }
448
449 set_state(port.data, data);
450 }
451 }
452
453 void update_ph1()
454 {
455 pool<Cell*> queue_cells;
456 pool<Wire*> queue_outports;
457
458 queue_cells.swap(dirty_cells);
459
460 while (1)
461 {
462 for (auto bit : dirty_bits)
463 {
464 if (upd_cells.count(bit))
465 for (auto cell : upd_cells.at(bit))
466 queue_cells.insert(cell);
467
468 if (upd_outports.count(bit) && parent != nullptr)
469 for (auto wire : upd_outports.at(bit))
470 queue_outports.insert(wire);
471 }
472
473 dirty_bits.clear();
474
475 if (!queue_cells.empty())
476 {
477 for (auto cell : queue_cells)
478 update_cell(cell);
479
480 queue_cells.clear();
481 continue;
482 }
483
484 for (auto &memid : dirty_memories)
485 update_memory(memid);
486 dirty_memories.clear();
487
488 for (auto wire : queue_outports)
489 if (instance->hasPort(wire->name)) {
490 Const value = get_state(wire);
491 parent->set_state(instance->getPort(wire->name), value);
492 }
493
494 queue_outports.clear();
495
496 for (auto child : dirty_children)
497 child->update_ph1();
498
499 dirty_children.clear();
500
501 if (dirty_bits.empty())
502 break;
503 }
504 }
505
506 bool update_ph2()
507 {
508 bool did_something = false;
509
510 for (auto &it : ff_database)
511 {
512 ff_state_t &ff = it.second;
513 FfData &ff_data = ff.data;
514
515 Const current_q = get_state(ff.data.sig_q);
516
517 if (ff_data.has_clk) {
518 // flip-flops
519 State current_clk = get_state(ff_data.sig_clk)[0];
520 if (ff_data.pol_clk ? (ff.past_clk == State::S0 && current_clk != State::S0) :
521 (ff.past_clk == State::S1 && current_clk != State::S1)) {
522 bool ce = ff.past_ce == (ff_data.pol_ce ? State::S1 : State::S0);
523 // set if no ce, or ce is enabled
524 if (!ff_data.has_ce || (ff_data.has_ce && ce)) {
525 current_q = ff.past_d;
526 }
527 // override if sync reset
528 if ((ff_data.has_srst) && (ff.past_srst == (ff_data.pol_srst ? State::S1 : State::S0)) &&
529 ((!ff_data.ce_over_srst) || (ff_data.ce_over_srst && ce))) {
530 current_q = ff_data.val_srst;
531 }
532 }
533 }
534 // async load
535 if (ff_data.has_aload) {
536 State current_aload = get_state(ff_data.sig_aload)[0];
537 if (current_aload == (ff_data.pol_aload ? State::S1 : State::S0)) {
538 current_q = ff_data.has_clk ? ff.past_ad : get_state(ff.data.sig_ad);
539 }
540 }
541 // async reset
542 if (ff_data.has_arst) {
543 State current_arst = get_state(ff_data.sig_arst)[0];
544 if (current_arst == (ff_data.pol_arst ? State::S1 : State::S0)) {
545 current_q = ff_data.val_arst;
546 }
547 }
548 // handle set/reset
549 if (ff.data.has_sr) {
550 Const current_clr = get_state(ff.data.sig_clr);
551 Const current_set = get_state(ff.data.sig_set);
552
553 for(int i=0;i<ff.past_d.size();i++) {
554 if (current_clr[i] == (ff_data.pol_clr ? State::S1 : State::S0)) {
555 current_q[i] = State::S0;
556 }
557 else if (current_set[i] == (ff_data.pol_set ? State::S1 : State::S0)) {
558 current_q[i] = State::S1;
559 }
560 }
561 }
562 if (ff_data.has_gclk) {
563 // $ff
564 current_q = ff.past_d;
565 }
566 if (set_state(ff_data.sig_q, current_q))
567 did_something = true;
568 }
569
570 for (auto &it : mem_database)
571 {
572 mem_state_t &mdb = it.second;
573 auto &mem = *mdb.mem;
574
575 for (int port_idx = 0; port_idx < GetSize(mem.wr_ports); port_idx++)
576 {
577 auto &port = mem.wr_ports[port_idx];
578 Const addr, data, enable;
579
580 if (!port.clk_enable)
581 {
582 addr = get_state(port.addr);
583 data = get_state(port.data);
584 enable = get_state(port.en);
585 }
586 else
587 {
588 if (port.clk_polarity ?
589 (mdb.past_wr_clk[port_idx] == State::S1 || get_state(port.clk) != State::S1) :
590 (mdb.past_wr_clk[port_idx] == State::S0 || get_state(port.clk) != State::S0))
591 continue;
592
593 addr = mdb.past_wr_addr[port_idx];
594 data = mdb.past_wr_data[port_idx];
595 enable = mdb.past_wr_en[port_idx];
596 }
597
598 if (addr.is_fully_def())
599 {
600 int index = addr.as_int() - mem.start_offset;
601 if (index >= 0 && index < mem.size)
602 for (int i = 0; i < (mem.width << port.wide_log2); i++)
603 if (enable[i] == State::S1 && mdb.data.bits.at(index*mem.width+i) != data[i]) {
604 mdb.data.bits.at(index*mem.width+i) = data[i];
605 dirty_memories.insert(mem.memid);
606 did_something = true;
607 }
608 }
609 }
610 }
611
612 for (auto it : children)
613 if (it.second->update_ph2()) {
614 dirty_children.insert(it.second);
615 did_something = true;
616 }
617
618 return did_something;
619 }
620
621 void update_ph3()
622 {
623 for (auto &it : ff_database)
624 {
625 ff_state_t &ff = it.second;
626
627 if (ff.data.has_aload)
628 ff.past_ad = get_state(ff.data.sig_ad);
629
630 if (ff.data.has_clk || ff.data.has_gclk)
631 ff.past_d = get_state(ff.data.sig_d);
632
633 if (ff.data.has_clk)
634 ff.past_clk = get_state(ff.data.sig_clk)[0];
635
636 if (ff.data.has_ce)
637 ff.past_ce = get_state(ff.data.sig_ce)[0];
638
639 if (ff.data.has_srst)
640 ff.past_srst = get_state(ff.data.sig_srst)[0];
641 }
642
643 for (auto &it : mem_database)
644 {
645 mem_state_t &mem = it.second;
646
647 for (int i = 0; i < GetSize(mem.mem->wr_ports); i++) {
648 auto &port = mem.mem->wr_ports[i];
649 mem.past_wr_clk[i] = get_state(port.clk);
650 mem.past_wr_en[i] = get_state(port.en);
651 mem.past_wr_addr[i] = get_state(port.addr);
652 mem.past_wr_data[i] = get_state(port.data);
653 }
654 }
655
656 for (auto cell : formal_database)
657 {
658 string label = log_id(cell);
659 if (cell->attributes.count(ID::src))
660 label = cell->attributes.at(ID::src).decode_string();
661
662 State a = get_state(cell->getPort(ID::A))[0];
663 State en = get_state(cell->getPort(ID::EN))[0];
664
665 if (cell->type == ID($cover) && en == State::S1 && a != State::S1)
666 log("Cover %s.%s (%s) reached.\n", hiername().c_str(), log_id(cell), label.c_str());
667
668 if (cell->type == ID($assume) && en == State::S1 && a != State::S1)
669 log("Assumption %s.%s (%s) failed.\n", hiername().c_str(), log_id(cell), label.c_str());
670
671 if (cell->type == ID($assert) && en == State::S1 && a != State::S1)
672 log_warning("Assert %s.%s (%s) failed.\n", hiername().c_str(), log_id(cell), label.c_str());
673 }
674
675 for (auto it : children)
676 it.second->update_ph3();
677 }
678
679 void writeback(pool<Module*> &wbmods)
680 {
681 if (wbmods.count(module))
682 log_error("Instance %s of module %s is not unique: Writeback not possible. (Fix by running 'uniquify'.)\n", hiername().c_str(), log_id(module));
683
684 wbmods.insert(module);
685
686 for (auto wire : module->wires())
687 wire->attributes.erase(ID::init);
688
689 for (auto &it : ff_database)
690 {
691 SigSpec sig_q = it.second.data.sig_q;
692 Const initval = get_state(sig_q);
693
694 for (int i = 0; i < GetSize(sig_q); i++)
695 {
696 Wire *w = sig_q[i].wire;
697
698 if (w->attributes.count(ID::init) == 0)
699 w->attributes[ID::init] = Const(State::Sx, GetSize(w));
700
701 w->attributes[ID::init][sig_q[i].offset] = initval[i];
702 }
703 }
704
705 for (auto &it : mem_database)
706 {
707 mem_state_t &mem = it.second;
708 mem.mem->clear_inits();
709 MemInit minit;
710 minit.addr = mem.mem->start_offset;
711 minit.data = mem.data;
712 minit.en = Const(State::S1, mem.mem->width);
713 mem.mem->inits.push_back(minit);
714 mem.mem->emit();
715 }
716
717 for (auto it : children)
718 it.second->writeback(wbmods);
719 }
720
721 void register_signals(int &id)
722 {
723 for (auto wire : module->wires())
724 {
725 if (shared->hide_internal && wire->name[0] == '$')
726 continue;
727
728 signal_database[wire] = make_pair(id, Const());
729 id++;
730 }
731
732 for (auto child : children)
733 child.second->register_signals(id);
734 }
735
736 void write_output_header(std::function<void(IdString)> enter_scope, std::function<void()> exit_scope, std::function<void(Wire*, int, bool)> register_signal)
737 {
738 enter_scope(name());
739
740 dict<Wire*,bool> registers;
741 for (auto cell : module->cells())
742 {
743 if (RTLIL::builtin_ff_cell_types().count(cell->type)) {
744 FfData ff_data(nullptr, cell);
745 SigSpec q = sigmap(ff_data.sig_q);
746 if (q.is_wire() && signal_database.count(q.as_wire()) != 0) {
747 registers[q.as_wire()] = true;
748 }
749 }
750 }
751
752 for (auto signal : signal_database)
753 {
754 register_signal(signal.first, signal.second.first, registers.count(signal.first)!=0);
755 }
756
757 for (auto child : children)
758 child.second->write_output_header(enter_scope, exit_scope, register_signal);
759
760 exit_scope();
761 }
762
763 void register_output_step_values(std::map<int,Const> *data)
764 {
765 for (auto &it : signal_database)
766 {
767 Wire *wire = it.first;
768 Const value = get_state(wire);
769 int id = it.second.first;
770
771 if (it.second.second == value)
772 continue;
773
774 it.second.second = value;
775 data->emplace(id, value);
776 }
777
778 for (auto child : children)
779 child.second->register_output_step_values(data);
780 }
781
782 bool setInitState()
783 {
784 bool did_something = false;
785 for (auto &it : ff_database)
786 {
787 ff_state_t &ff = it.second;
788 SigSpec qsig = it.second.data.sig_q;
789 if (qsig.is_wire()) {
790 IdString name = qsig.as_wire()->name;
791 fstHandle id = shared->fst->getHandle(scope + "." + RTLIL::unescape_id(name));
792 if (id==0 && name.isPublic())
793 log_warning("Unable to find wire %s in input file.\n", (scope + "." + RTLIL::unescape_id(name)).c_str());
794 if (id!=0) {
795 Const fst_val = Const::from_string(shared->fst->valueOf(id));
796 ff.past_d = fst_val;
797 if (ff.data.has_aload)
798 ff.past_ad = fst_val;
799 did_something = set_state(qsig, fst_val);
800 }
801 }
802 }
803 for (auto child : children)
804 did_something |= child.second->setInitState();
805 return did_something;
806 }
807
808 void setState(dict<int, std::pair<SigBit,bool>> bits, std::string values)
809 {
810 for(auto bit : bits) {
811 if (bit.first >= GetSize(values))
812 log_error("Too few input data bits in file.\n");
813 switch(values.at(bit.first)) {
814 case '0': set_state(bit.second.first, bit.second.second ? State::S1 : State::S0); break;
815 case '1': set_state(bit.second.first, bit.second.second ? State::S0 : State::S1); break;
816 default: set_state(bit.second.first, State::Sx); break;
817 }
818 }
819 }
820
821 void setMemState(dict<int, std::pair<std::string,int>> bits, std::string values)
822 {
823 for(auto bit : bits) {
824 if (bit.first >= GetSize(values))
825 log_error("Too few input data bits in file.\n");
826 switch(values.at(bit.first)) {
827 case '0': set_memory_state_bit(bit.second.first, bit.second.second, State::S0); break;
828 case '1': set_memory_state_bit(bit.second.first, bit.second.second, State::S1); break;
829 default: set_memory_state_bit(bit.second.first, bit.second.second, State::Sx); break;
830 }
831 }
832 }
833
834 bool checkSignals()
835 {
836 bool retVal = false;
837 for(auto &item : fst_handles) {
838 if (item.second==0) continue; // Ignore signals not found
839 Const fst_val = Const::from_string(shared->fst->valueOf(item.second));
840 Const sim_val = get_state(item.first);
841 if (sim_val.size()!=fst_val.size()) {
842 log_warning("Signal '%s.%s' size is different in gold and gate.\n", scope.c_str(), log_id(item.first));
843 continue;
844 }
845 if (shared->sim_mode == SimulationMode::sim) {
846 // No checks performed when using stimulus
847 } else if (shared->sim_mode == SimulationMode::gate && !fst_val.is_fully_def()) { // FST data contains X
848 for(int i=0;i<fst_val.size();i++) {
849 if (fst_val[i]!=State::Sx && fst_val[i]!=sim_val[i]) {
850 log_warning("Signal '%s.%s' in file %s in simulation %s\n", scope.c_str(), log_id(item.first), log_signal(fst_val), log_signal(sim_val));
851 retVal = true;
852 break;
853 }
854 }
855 } else if (shared->sim_mode == SimulationMode::gold && !sim_val.is_fully_def()) { // sim data contains X
856 for(int i=0;i<sim_val.size();i++) {
857 if (sim_val[i]!=State::Sx && fst_val[i]!=sim_val[i]) {
858 log_warning("Signal '%s.%s' in file %s in simulation %s\n", scope.c_str(), log_id(item.first), log_signal(fst_val), log_signal(sim_val));
859 retVal = true;
860 break;
861 }
862 }
863 } else {
864 if (fst_val!=sim_val) {
865 log_warning("Signal '%s.%s' in file %s in simulation '%s'\n", scope.c_str(), log_id(item.first), log_signal(fst_val), log_signal(sim_val));
866 retVal = true;
867 }
868 }
869 }
870 for (auto child : children)
871 retVal |= child.second->checkSignals();
872 return retVal;
873 }
874 };
875
876 struct SimWorker : SimShared
877 {
878 SimInstance *top = nullptr;
879 pool<IdString> clock, clockn, reset, resetn;
880 std::string timescale;
881 std::string sim_filename;
882 std::string map_filename;
883 std::string scope;
884
885 ~SimWorker()
886 {
887 outputfiles.clear();
888 delete top;
889 }
890
891 void register_signals()
892 {
893 int id = 1;
894 top->register_signals(id);
895 }
896
897 void register_output_step(int t)
898 {
899 std::map<int,Const> data;
900 top->register_output_step_values(&data);
901 output_data.emplace_back(t, data);
902 }
903
904 void write_output_files()
905 {
906 std::map<int, bool> use_signal;
907 bool first = ignore_x;
908 for(auto& d : output_data)
909 {
910 if (first) {
911 for (auto &data : d.second)
912 use_signal[data.first] = !data.second.is_fully_undef();
913 first = false;
914 } else {
915 for (auto &data : d.second)
916 use_signal[data.first] = true;
917 }
918 if (!ignore_x) break;
919 }
920 for(auto& writer : outputfiles)
921 writer->write(use_signal);
922 }
923
924 void update()
925 {
926 while (1)
927 {
928 if (debug)
929 log("\n-- ph1 --\n");
930
931 top->update_ph1();
932
933 if (debug)
934 log("\n-- ph2 --\n");
935
936 if (!top->update_ph2())
937 break;
938 }
939
940 if (debug)
941 log("\n-- ph3 --\n");
942
943 top->update_ph3();
944 }
945
946 void set_inports(pool<IdString> ports, State value)
947 {
948 for (auto portname : ports)
949 {
950 Wire *w = top->module->wire(portname);
951
952 if (w == nullptr)
953 log_error("Can't find port %s on module %s.\n", log_id(portname), log_id(top->module));
954
955 top->set_state(w, value);
956 }
957 }
958
959 void run(Module *topmod, int numcycles)
960 {
961 log_assert(top == nullptr);
962 top = new SimInstance(this, scope, topmod);
963 register_signals();
964
965 if (debug)
966 log("\n===== 0 =====\n");
967 else if (verbose)
968 log("Simulating cycle 0.\n");
969
970 set_inports(reset, State::S1);
971 set_inports(resetn, State::S0);
972
973 set_inports(clock, State::Sx);
974 set_inports(clockn, State::Sx);
975
976 update();
977
978 register_output_step(0);
979
980 for (int cycle = 0; cycle < numcycles; cycle++)
981 {
982 if (debug)
983 log("\n===== %d =====\n", 10*cycle + 5);
984 else if (verbose)
985 log("Simulating cycle %d.\n", (cycle*2)+1);
986 set_inports(clock, State::S0);
987 set_inports(clockn, State::S1);
988
989 update();
990 register_output_step(10*cycle + 5);
991
992 if (debug)
993 log("\n===== %d =====\n", 10*cycle + 10);
994 else if (verbose)
995 log("Simulating cycle %d.\n", (cycle*2)+2);
996
997 set_inports(clock, State::S1);
998 set_inports(clockn, State::S0);
999
1000 if (cycle+1 == rstlen) {
1001 set_inports(reset, State::S0);
1002 set_inports(resetn, State::S1);
1003 }
1004
1005 update();
1006 register_output_step(10*cycle + 10);
1007 }
1008
1009 register_output_step(10*numcycles + 2);
1010
1011 write_output_files();
1012
1013 if (writeback) {
1014 pool<Module*> wbmods;
1015 top->writeback(wbmods);
1016 }
1017 }
1018
1019 void run_cosim_fst(Module *topmod, int numcycles)
1020 {
1021 log_assert(top == nullptr);
1022 fst = new FstData(sim_filename);
1023
1024 if (scope.empty())
1025 log_error("Scope must be defined for co-simulation.\n");
1026
1027 top = new SimInstance(this, scope, topmod);
1028 register_signals();
1029
1030 std::vector<fstHandle> fst_clock;
1031
1032 for (auto portname : clock)
1033 {
1034 Wire *w = topmod->wire(portname);
1035 if (!w)
1036 log_error("Can't find port %s on module %s.\n", log_id(portname), log_id(top->module));
1037 if (!w->port_input)
1038 log_error("Clock port %s on module %s is not input.\n", log_id(portname), log_id(top->module));
1039 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(portname));
1040 if (id==0)
1041 log_error("Can't find port %s.%s in FST.\n", scope.c_str(), log_id(portname));
1042 fst_clock.push_back(id);
1043 }
1044 for (auto portname : clockn)
1045 {
1046 Wire *w = topmod->wire(portname);
1047 if (!w)
1048 log_error("Can't find port %s on module %s.\n", log_id(portname), log_id(top->module));
1049 if (!w->port_input)
1050 log_error("Clock port %s on module %s is not input.\n", log_id(portname), log_id(top->module));
1051 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(portname));
1052 if (id==0)
1053 log_error("Can't find port %s.%s in FST.\n", scope.c_str(), log_id(portname));
1054 fst_clock.push_back(id);
1055 }
1056
1057 SigMap sigmap(topmod);
1058 std::map<Wire*,fstHandle> inputs;
1059
1060 for (auto wire : topmod->wires()) {
1061 if (wire->port_input) {
1062 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(wire->name));
1063 if (id==0)
1064 log_error("Unable to find required '%s' signal in file\n",(scope + "." + RTLIL::unescape_id(wire->name)).c_str());
1065 inputs[wire] = id;
1066 }
1067 }
1068
1069 uint64_t startCount = 0;
1070 uint64_t stopCount = 0;
1071 if (start_time==0) {
1072 if (start_time < fst->getStartTime())
1073 log_warning("Start time is before simulation file start time\n");
1074 startCount = fst->getStartTime();
1075 } else if (start_time==-1)
1076 startCount = fst->getEndTime();
1077 else {
1078 startCount = start_time / fst->getTimescale();
1079 if (startCount > fst->getEndTime()) {
1080 startCount = fst->getEndTime();
1081 log_warning("Start time is after simulation file end time\n");
1082 }
1083 }
1084 if (stop_time==0) {
1085 if (stop_time < fst->getStartTime())
1086 log_warning("Stop time is before simulation file start time\n");
1087 stopCount = fst->getStartTime();
1088 } else if (stop_time==-1)
1089 stopCount = fst->getEndTime();
1090 else {
1091 stopCount = stop_time / fst->getTimescale();
1092 if (stopCount > fst->getEndTime()) {
1093 stopCount = fst->getEndTime();
1094 log_warning("Stop time is after simulation file end time\n");
1095 }
1096 }
1097 if (stopCount<startCount) {
1098 log_error("Stop time is before start time\n");
1099 }
1100
1101 bool initial = true;
1102 int cycle = 0;
1103 log("Co-simulation from %lu%s to %lu%s", (unsigned long)startCount, fst->getTimescaleString(), (unsigned long)stopCount, fst->getTimescaleString());
1104 if (cycles_set)
1105 log(" for %d clock cycle(s)",numcycles);
1106 log("\n");
1107 bool all_samples = fst_clock.empty();
1108
1109 try {
1110 fst->reconstructAllAtTimes(fst_clock, startCount, stopCount, [&](uint64_t time) {
1111 if (verbose)
1112 log("Co-simulating %s %d [%lu%s].\n", (all_samples ? "sample" : "cycle"), cycle, (unsigned long)time, fst->getTimescaleString());
1113 bool did_something = false;
1114 for(auto &item : inputs) {
1115 std::string v = fst->valueOf(item.second);
1116 did_something |= top->set_state(item.first, Const::from_string(v));
1117 }
1118
1119 if (initial) {
1120 did_something |= top->setInitState();
1121 initial = false;
1122 }
1123 if (did_something)
1124 update();
1125 register_output_step(time);
1126
1127 bool status = top->checkSignals();
1128 if (status)
1129 log_error("Signal difference\n");
1130 cycle++;
1131
1132 // Limit to number of cycles if provided
1133 if (cycles_set && cycle > numcycles *2)
1134 throw fst_end_of_data_exception();
1135 if (time==stopCount)
1136 throw fst_end_of_data_exception();
1137 });
1138 } catch(fst_end_of_data_exception) {
1139 // end of data detected
1140 }
1141
1142 write_output_files();
1143
1144 if (writeback) {
1145 pool<Module*> wbmods;
1146 top->writeback(wbmods);
1147 }
1148 delete fst;
1149 }
1150
1151 std::string cell_name(std::string const & name)
1152 {
1153 size_t pos = name.find_last_of("[");
1154 if (pos!=std::string::npos)
1155 return name.substr(0, pos);
1156 return name;
1157 }
1158
1159 int mem_cell_addr(std::string const & name)
1160 {
1161 size_t pos = name.find_last_of("[");
1162 return atoi(name.substr(pos+1).c_str());
1163 }
1164
1165 void run_cosim_aiger_witness(Module *topmod)
1166 {
1167 log_assert(top == nullptr);
1168 if (!multiclock && (clock.size()+clockn.size())==0)
1169 log_error("Clock signal must be specified.\n");
1170 if (multiclock && (clock.size()+clockn.size())>0)
1171 log_error("For multiclock witness there should be no clock signal.\n");
1172
1173 top = new SimInstance(this, scope, topmod);
1174 register_signals();
1175
1176 std::ifstream mf(map_filename);
1177 std::string type, symbol;
1178 int variable, index;
1179 dict<int, std::pair<SigBit,bool>> inputs, inits, latches;
1180 dict<int, std::pair<std::string,int>> mem_inits, mem_latches;
1181 if (mf.fail())
1182 log_cmd_error("Not able to read AIGER witness map file.\n");
1183 while (mf >> type >> variable >> index >> symbol) {
1184 RTLIL::IdString escaped_s = RTLIL::escape_id(symbol);
1185 Wire *w = topmod->wire(escaped_s);
1186 if (!w) {
1187 escaped_s = RTLIL::escape_id(cell_name(symbol));
1188 Cell *c = topmod->cell(escaped_s);
1189 if (!c)
1190 log_warning("Wire/cell %s not present in module %s\n",symbol.c_str(),log_id(topmod));
1191
1192 if (c->is_mem_cell()) {
1193 std::string memid = c->parameters.at(ID::MEMID).decode_string();
1194 auto &state = top->mem_database[memid];
1195
1196 int offset = (mem_cell_addr(symbol) - state.mem->start_offset) * state.mem->width + index;
1197 if (type == "init")
1198 mem_inits[variable] = { memid, offset };
1199 else if (type == "latch")
1200 mem_latches[variable] = { memid, offset };
1201 else
1202 log_error("Map file addressing cell %s as type %s\n", symbol.c_str(), type.c_str());
1203 } else {
1204 log_error("Cell %s in map file is not memory cell\n", symbol.c_str());
1205 }
1206 } else {
1207 if (index < w->start_offset || index > w->start_offset + w->width)
1208 log_error("Index %d for wire %s is out of range\n", index, log_signal(w));
1209 if (type == "input") {
1210 inputs[variable] = {SigBit(w,index-w->start_offset), false};
1211 } else if (type == "init") {
1212 inits[variable] = {SigBit(w,index-w->start_offset), false};
1213 } else if (type == "latch") {
1214 latches[variable] = {SigBit(w,index-w->start_offset), false};
1215 } else if (type == "invlatch") {
1216 latches[variable] = {SigBit(w,index-w->start_offset), true};
1217 }
1218 }
1219 }
1220
1221 std::ifstream f;
1222 f.open(sim_filename.c_str());
1223 if (f.fail() || GetSize(sim_filename) == 0)
1224 log_error("Can not open file `%s`\n", sim_filename.c_str());
1225
1226 int state = 0;
1227 std::string status;
1228 int cycle = 0;
1229
1230 while (!f.eof())
1231 {
1232 std::string line;
1233 std::getline(f, line);
1234 if (line.size()==0 || line[0]=='#' || line[0]=='c' || line[0]=='f' || line[0]=='u') continue;
1235 if (line[0]=='.') break;
1236 if (state==0 && line.size()!=1) {
1237 // old format detected, latch data
1238 state = 2;
1239 }
1240 if (state==1 && line[0]!='b' && line[0]!='j') {
1241 // was old format but with 1 bit latch
1242 top->setState(latches, status);
1243 state = 3;
1244 }
1245
1246 switch(state)
1247 {
1248 case 0:
1249 status = line;
1250 state = 1;
1251 break;
1252 case 1:
1253 state = 2;
1254 break;
1255 case 2:
1256 top->setState(latches, line);
1257 top->setMemState(mem_latches, line);
1258 state = 3;
1259 break;
1260 default:
1261 if (verbose)
1262 log("Simulating cycle %d.\n", cycle);
1263 top->setState(inputs, line);
1264 if (cycle) {
1265 set_inports(clock, State::S1);
1266 set_inports(clockn, State::S0);
1267 } else {
1268 top->setState(inits, line);
1269 top->setMemState(mem_inits, line);
1270 set_inports(clock, State::S0);
1271 set_inports(clockn, State::S1);
1272 }
1273 update();
1274 register_output_step(10*cycle);
1275 if (!multiclock && cycle) {
1276 set_inports(clock, State::S0);
1277 set_inports(clockn, State::S1);
1278 update();
1279 register_output_step(10*cycle + 5);
1280 }
1281 cycle++;
1282 break;
1283 }
1284 }
1285 register_output_step(10*cycle);
1286 write_output_files();
1287 }
1288
1289 std::vector<std::string> split(std::string text, const char *delim)
1290 {
1291 std::vector<std::string> list;
1292 char *p = strdup(text.c_str());
1293 char *t = strtok(p, delim);
1294 while (t != NULL) {
1295 list.push_back(t);
1296 t = strtok(NULL, delim);
1297 }
1298 free(p);
1299 return list;
1300 }
1301
1302 std::string signal_name(std::string const & name)
1303 {
1304 size_t pos = name.find_first_of("@");
1305 if (pos==std::string::npos) {
1306 pos = name.find_first_of("#");
1307 if (pos==std::string::npos)
1308 log_error("Line does not contain proper signal name `%s`\n", name.c_str());
1309 }
1310 return name.substr(0, pos);
1311 }
1312
1313 void run_cosim_btor2_witness(Module *topmod)
1314 {
1315 log_assert(top == nullptr);
1316 if ((clock.size()+clockn.size())==0)
1317 log_error("Clock signal must be specified.\n");
1318 std::ifstream f;
1319 f.open(sim_filename.c_str());
1320 if (f.fail() || GetSize(sim_filename) == 0)
1321 log_error("Can not open file `%s`\n", sim_filename.c_str());
1322
1323 int state = 0;
1324 int cycle = 0;
1325 top = new SimInstance(this, scope, topmod);
1326 register_signals();
1327 int prev_cycle = 0;
1328 int curr_cycle = 0;
1329 std::vector<std::string> parts;
1330 size_t len = 0;
1331 while (!f.eof())
1332 {
1333 std::string line;
1334 std::getline(f, line);
1335 if (line.size()==0) continue;
1336
1337 if (line[0]=='#' || line[0]=='@' || line[0]=='.') {
1338 if (line[0]!='.')
1339 curr_cycle = atoi(line.c_str()+1);
1340 else
1341 curr_cycle = -1; // force detect change
1342
1343 if (curr_cycle != prev_cycle) {
1344 if (verbose)
1345 log("Simulating cycle %d.\n", cycle);
1346 set_inports(clock, State::S1);
1347 set_inports(clockn, State::S0);
1348 update();
1349 register_output_step(10*cycle+0);
1350 set_inports(clock, State::S0);
1351 set_inports(clockn, State::S1);
1352 update();
1353 register_output_step(10*cycle+5);
1354 cycle++;
1355 prev_cycle = curr_cycle;
1356 }
1357 if (line[0]=='.') break;
1358 continue;
1359 }
1360
1361 switch(state)
1362 {
1363 case 0:
1364 if (line=="sat")
1365 state = 1;
1366 break;
1367 case 1:
1368 if (line[0]=='b' || line[0]=='j')
1369 state = 2;
1370 else
1371 log_error("Line does not contain property.\n");
1372 break;
1373 default: // set state or inputs
1374 parts = split(line, " ");
1375 len = parts.size();
1376 if (len<3 || len>4)
1377 log_error("Invalid set state line content.\n");
1378
1379 RTLIL::IdString escaped_s = RTLIL::escape_id(signal_name(parts[len-1]));
1380 if (len==3) {
1381 Wire *w = topmod->wire(escaped_s);
1382 if (!w) {
1383 Cell *c = topmod->cell(escaped_s);
1384 if (!c)
1385 log_warning("Wire/cell %s not present in module %s\n",log_id(escaped_s),log_id(topmod));
1386 else if (c->type.in(ID($anyconst), ID($anyseq))) {
1387 SigSpec sig_y= c->getPort(ID::Y);
1388 if ((int)parts[1].size() != GetSize(sig_y))
1389 log_error("Size of wire %s is different than provided data.\n", log_signal(sig_y));
1390 top->set_state(sig_y, Const::from_string(parts[1]));
1391 }
1392 } else {
1393 if ((int)parts[1].size() != w->width)
1394 log_error("Size of wire %s is different than provided data.\n", log_signal(w));
1395 top->set_state(w, Const::from_string(parts[1]));
1396 }
1397 } else {
1398 Cell *c = topmod->cell(escaped_s);
1399 if (!c)
1400 log_error("Cell %s not present in module %s\n",log_id(escaped_s),log_id(topmod));
1401 if (!c->is_mem_cell())
1402 log_error("Cell %s is not memory cell in module %s\n",log_id(escaped_s),log_id(topmod));
1403
1404 Const addr = Const::from_string(parts[1].substr(1,parts[1].size()-2));
1405 Const data = Const::from_string(parts[2]);
1406 top->set_memory_state(c->parameters.at(ID::MEMID).decode_string(), addr, data);
1407 }
1408 break;
1409 }
1410 }
1411 register_output_step(10*cycle);
1412 write_output_files();
1413 }
1414
1415 std::string define_signal(Wire *wire)
1416 {
1417 std::stringstream f;
1418
1419 if (wire->width==1)
1420 f << stringf("%s", RTLIL::unescape_id(wire->name).c_str());
1421 else
1422 if (wire->upto)
1423 f << stringf("[%d:%d] %s", wire->start_offset, wire->width - 1 + wire->start_offset, RTLIL::unescape_id(wire->name).c_str());
1424 else
1425 f << stringf("[%d:%d] %s", wire->width - 1 + wire->start_offset, wire->start_offset, RTLIL::unescape_id(wire->name).c_str());
1426 return f.str();
1427 }
1428
1429 std::string signal_list(std::map<Wire*,fstHandle> &signals)
1430 {
1431 std::stringstream f;
1432 for(auto item=signals.begin();item!=signals.end();item++)
1433 f << stringf("%c%s", (item==signals.begin() ? ' ' : ','), RTLIL::unescape_id(item->first->name).c_str());
1434 return f.str();
1435 }
1436
1437 void generate_tb(Module *topmod, std::string tb_filename, int numcycles)
1438 {
1439 fst = new FstData(sim_filename);
1440
1441 if (scope.empty())
1442 log_error("Scope must be defined for co-simulation.\n");
1443
1444 if ((clock.size()+clockn.size())==0)
1445 log_error("Clock signal must be specified.\n");
1446
1447 std::vector<fstHandle> fst_clock;
1448 std::map<Wire*,fstHandle> clocks;
1449
1450 for (auto portname : clock)
1451 {
1452 Wire *w = topmod->wire(portname);
1453 if (!w)
1454 log_error("Can't find port %s on module %s.\n", log_id(portname), log_id(top->module));
1455 if (!w->port_input)
1456 log_error("Clock port %s on module %s is not input.\n", log_id(portname), log_id(top->module));
1457 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(portname));
1458 if (id==0)
1459 log_error("Can't find port %s.%s in FST.\n", scope.c_str(), log_id(portname));
1460 fst_clock.push_back(id);
1461 clocks[w] = id;
1462 }
1463 for (auto portname : clockn)
1464 {
1465 Wire *w = topmod->wire(portname);
1466 if (!w)
1467 log_error("Can't find port %s on module %s.\n", log_id(portname), log_id(top->module));
1468 if (!w->port_input)
1469 log_error("Clock port %s on module %s is not input.\n", log_id(portname), log_id(top->module));
1470 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(portname));
1471 if (id==0)
1472 log_error("Can't find port %s.%s in FST.\n", scope.c_str(), log_id(portname));
1473 fst_clock.push_back(id);
1474 clocks[w] = id;
1475 }
1476
1477 SigMap sigmap(topmod);
1478 std::map<Wire*,fstHandle> inputs;
1479 std::map<Wire*,fstHandle> outputs;
1480
1481 for (auto wire : topmod->wires()) {
1482 fstHandle id = fst->getHandle(scope + "." + RTLIL::unescape_id(wire->name));
1483 if (id==0 && (wire->port_input || wire->port_output))
1484 log_error("Unable to find required '%s' signal in file\n",(scope + "." + RTLIL::unescape_id(wire->name)).c_str());
1485 if (wire->port_input)
1486 if (clocks.find(wire)==clocks.end())
1487 inputs[wire] = id;
1488 if (wire->port_output)
1489 outputs[wire] = id;
1490 }
1491
1492 uint64_t startCount = 0;
1493 uint64_t stopCount = 0;
1494 if (start_time==0) {
1495 if (start_time < fst->getStartTime())
1496 log_warning("Start time is before simulation file start time\n");
1497 startCount = fst->getStartTime();
1498 } else if (start_time==-1)
1499 startCount = fst->getEndTime();
1500 else {
1501 startCount = start_time / fst->getTimescale();
1502 if (startCount > fst->getEndTime()) {
1503 startCount = fst->getEndTime();
1504 log_warning("Start time is after simulation file end time\n");
1505 }
1506 }
1507 if (stop_time==0) {
1508 if (stop_time < fst->getStartTime())
1509 log_warning("Stop time is before simulation file start time\n");
1510 stopCount = fst->getStartTime();
1511 } else if (stop_time==-1)
1512 stopCount = fst->getEndTime();
1513 else {
1514 stopCount = stop_time / fst->getTimescale();
1515 if (stopCount > fst->getEndTime()) {
1516 stopCount = fst->getEndTime();
1517 log_warning("Stop time is after simulation file end time\n");
1518 }
1519 }
1520 if (stopCount<startCount) {
1521 log_error("Stop time is before start time\n");
1522 }
1523
1524 int cycle = 0;
1525 log("Generate testbench data from %lu%s to %lu%s", (unsigned long)startCount, fst->getTimescaleString(), (unsigned long)stopCount, fst->getTimescaleString());
1526 if (cycles_set)
1527 log(" for %d clock cycle(s)",numcycles);
1528 log("\n");
1529
1530 std::stringstream f;
1531 f << stringf("`timescale 1%s/1%s\n", fst->getTimescaleString(),fst->getTimescaleString());
1532 f << stringf("module %s();\n",tb_filename.c_str());
1533 int clk_len = 0;
1534 int inputs_len = 0;
1535 int outputs_len = 0;
1536 for(auto &item : clocks) {
1537 clk_len += item.first->width;
1538 f << "\treg " << define_signal(item.first) << ";\n";
1539 }
1540 for(auto &item : inputs) {
1541 inputs_len += item.first->width;
1542 f << "\treg " << define_signal(item.first) << ";\n";
1543 }
1544 for(auto &item : outputs) {
1545 outputs_len += item.first->width;
1546 f << "\twire " << define_signal(item.first) << ";\n";
1547 }
1548 int data_len = clk_len + inputs_len + outputs_len + 32;
1549 f << "\n";
1550 f << stringf("\t%s uut(",RTLIL::unescape_id(topmod->name).c_str());
1551 for(auto item=clocks.begin();item!=clocks.end();item++)
1552 f << stringf("%c.%s(%s)", (item==clocks.begin() ? ' ' : ','), RTLIL::unescape_id(item->first->name).c_str(), RTLIL::unescape_id(item->first->name).c_str());
1553 for(auto &item : inputs)
1554 f << stringf(",.%s(%s)", RTLIL::unescape_id(item.first->name).c_str(), RTLIL::unescape_id(item.first->name).c_str());
1555 for(auto &item : outputs)
1556 f << stringf(",.%s(%s)", RTLIL::unescape_id(item.first->name).c_str(), RTLIL::unescape_id(item.first->name).c_str());
1557 f << ");\n";
1558 f << "\n";
1559 f << "\tinteger i;\n";
1560 uint64_t prev_time = startCount;
1561 log("Writing data to `%s`\n", (tb_filename+".txt").c_str());
1562 std::ofstream data_file(tb_filename+".txt");
1563 std::stringstream initstate;
1564 try {
1565 fst->reconstructAllAtTimes(fst_clock, startCount, stopCount, [&](uint64_t time) {
1566 for(auto &item : clocks)
1567 data_file << stringf("%s",fst->valueOf(item.second).c_str());
1568 for(auto &item : inputs)
1569 data_file << stringf("%s",fst->valueOf(item.second).c_str());
1570 for(auto &item : outputs)
1571 data_file << stringf("%s",fst->valueOf(item.second).c_str());
1572 data_file << stringf("%s\n",Const(time-prev_time).as_string().c_str());
1573
1574 if (time==startCount) {
1575 // initial state
1576 for(auto var : fst->getVars()) {
1577 if (var.is_reg && !Const::from_string(fst->valueOf(var.id).c_str()).is_fully_undef()) {
1578 if (var.scope == scope) {
1579 initstate << stringf("\t\tuut.%s = %d'b%s;\n", var.name.c_str(), var.width, fst->valueOf(var.id).c_str());
1580 } else if (var.scope.find(scope+".")==0) {
1581 initstate << stringf("\t\tuut.%s.%s = %d'b%s;\n",var.scope.substr(scope.size()+1).c_str(), var.name.c_str(), var.width, fst->valueOf(var.id).c_str());
1582 }
1583 }
1584 }
1585 }
1586 cycle++;
1587 prev_time = time;
1588
1589 // Limit to number of cycles if provided
1590 if (cycles_set && cycle > numcycles *2)
1591 throw fst_end_of_data_exception();
1592 if (time==stopCount)
1593 throw fst_end_of_data_exception();
1594 });
1595 } catch(fst_end_of_data_exception) {
1596 // end of data detected
1597 }
1598
1599 f << stringf("\treg [0:%d] data [0:%d];\n", data_len-1, cycle-1);
1600 f << "\tinitial begin;\n";
1601 f << stringf("\t\t$dumpfile(\"%s\");\n",tb_filename.c_str());
1602 f << stringf("\t\t$dumpvars(0,%s);\n",tb_filename.c_str());
1603 f << initstate.str();
1604 f << stringf("\t\t$readmemb(\"%s.txt\", data);\n",tb_filename.c_str());
1605
1606 f << stringf("\t\t#(data[0][%d:%d]);\n", data_len-32, data_len-1);
1607 f << stringf("\t\t{%s } = data[0][%d:%d];\n", signal_list(clocks).c_str(), 0, clk_len-1);
1608 f << stringf("\t\t{%s } <= data[0][%d:%d];\n", signal_list(inputs).c_str(), clk_len, clk_len+inputs_len-1);
1609
1610 f << stringf("\t\tfor (i = 1; i < %d; i++) begin\n",cycle);
1611
1612 f << stringf("\t\t\t#(data[i][%d:%d]);\n", data_len-32, data_len-1);
1613 f << stringf("\t\t\t{%s } = data[i][%d:%d];\n", signal_list(clocks).c_str(), 0, clk_len-1);
1614 f << stringf("\t\t\t{%s } <= data[i][%d:%d];\n", signal_list(inputs).c_str(), clk_len, clk_len+inputs_len-1);
1615
1616 f << stringf("\t\t\tif ({%s } != data[i-1][%d:%d]) begin\n", signal_list(outputs).c_str(), clk_len+inputs_len, clk_len+inputs_len+outputs_len-1);
1617 f << "\t\t\t\t$error(\"Signal difference detected\\n\");\n";
1618 f << "\t\t\tend\n";
1619
1620 f << "\t\tend\n";
1621
1622 f << "\t\t$finish;\n";
1623 f << "\tend\n";
1624 f << "endmodule\n";
1625
1626 log("Writing testbench to `%s`\n", (tb_filename+".v").c_str());
1627 std::ofstream tb_file(tb_filename+".v");
1628 tb_file << f.str();
1629
1630 delete fst;
1631 }
1632 };
1633
1634 struct VCDWriter : public OutputWriter
1635 {
1636 VCDWriter(SimWorker *worker, std::string filename) : OutputWriter(worker) {
1637 vcdfile.open(filename.c_str());
1638 }
1639
1640 void write(std::map<int, bool> &use_signal) override
1641 {
1642 if (!vcdfile.is_open()) return;
1643 vcdfile << stringf("$version %s $end\n", worker->date ? yosys_version_str : "Yosys");
1644
1645 if (worker->date) {
1646 std::time_t t = std::time(nullptr);
1647 char mbstr[255];
1648 if (std::strftime(mbstr, sizeof(mbstr), "%c", std::localtime(&t))) {
1649 vcdfile << stringf("$date ") << mbstr << stringf(" $end\n");
1650 }
1651 }
1652
1653 if (!worker->timescale.empty())
1654 vcdfile << stringf("$timescale %s $end\n", worker->timescale.c_str());
1655
1656 worker->top->write_output_header(
1657 [this](IdString name) { vcdfile << stringf("$scope module %s $end\n", log_id(name)); },
1658 [this]() { vcdfile << stringf("$upscope $end\n");},
1659 [this,use_signal](Wire *wire, int id, bool is_reg) { if (use_signal.at(id)) vcdfile << stringf("$var %s %d n%d %s%s $end\n", is_reg ? "reg" : "wire", GetSize(wire), id, wire->name[0] == '$' ? "\\" : "", log_id(wire)); }
1660 );
1661
1662 vcdfile << stringf("$enddefinitions $end\n");
1663
1664 for(auto& d : worker->output_data)
1665 {
1666 vcdfile << stringf("#%d\n", d.first);
1667 for (auto &data : d.second)
1668 {
1669 if (!use_signal.at(data.first)) continue;
1670 Const value = data.second;
1671 vcdfile << "b";
1672 for (int i = GetSize(value)-1; i >= 0; i--) {
1673 switch (value[i]) {
1674 case State::S0: vcdfile << "0"; break;
1675 case State::S1: vcdfile << "1"; break;
1676 case State::Sx: vcdfile << "x"; break;
1677 default: vcdfile << "z";
1678 }
1679 }
1680 vcdfile << stringf(" n%d\n", data.first);
1681 }
1682 }
1683 }
1684
1685 std::ofstream vcdfile;
1686 };
1687
1688 struct FSTWriter : public OutputWriter
1689 {
1690 FSTWriter(SimWorker *worker, std::string filename) : OutputWriter(worker) {
1691 fstfile = (struct fstContext *)fstWriterCreate(filename.c_str(),1);
1692 }
1693
1694 virtual ~FSTWriter()
1695 {
1696 fstWriterClose(fstfile);
1697 }
1698
1699 void write(std::map<int, bool> &use_signal) override
1700 {
1701 if (!fstfile) return;
1702 std::time_t t = std::time(nullptr);
1703 fstWriterSetVersion(fstfile, worker->date ? yosys_version_str : "Yosys");
1704 if (worker->date)
1705 fstWriterSetDate(fstfile, asctime(std::localtime(&t)));
1706 else
1707 fstWriterSetDate(fstfile, "");
1708 if (!worker->timescale.empty())
1709 fstWriterSetTimescaleFromString(fstfile, worker->timescale.c_str());
1710
1711 fstWriterSetPackType(fstfile, FST_WR_PT_FASTLZ);
1712 fstWriterSetRepackOnClose(fstfile, 1);
1713
1714 worker->top->write_output_header(
1715 [this](IdString name) { fstWriterSetScope(fstfile, FST_ST_VCD_MODULE, stringf("%s",log_id(name)).c_str(), nullptr); },
1716 [this]() { fstWriterSetUpscope(fstfile); },
1717 [this,use_signal](Wire *wire, int id, bool is_reg) {
1718 if (!use_signal.at(id)) return;
1719 fstHandle fst_id = fstWriterCreateVar(fstfile, is_reg ? FST_VT_VCD_REG : FST_VT_VCD_WIRE, FST_VD_IMPLICIT, GetSize(wire),
1720 stringf("%s%s", wire->name[0] == '$' ? "\\" : "", log_id(wire)).c_str(), 0);
1721
1722 mapping.emplace(id, fst_id);
1723 }
1724 );
1725
1726 for(auto& d : worker->output_data)
1727 {
1728 fstWriterEmitTimeChange(fstfile, d.first);
1729 for (auto &data : d.second)
1730 {
1731 if (!use_signal.at(data.first)) continue;
1732 Const value = data.second;
1733 std::stringstream ss;
1734 for (int i = GetSize(value)-1; i >= 0; i--) {
1735 switch (value[i]) {
1736 case State::S0: ss << "0"; break;
1737 case State::S1: ss << "1"; break;
1738 case State::Sx: ss << "x"; break;
1739 default: ss << "z";
1740 }
1741 }
1742 fstWriterEmitValueChange(fstfile, mapping[data.first], ss.str().c_str());
1743 }
1744 }
1745 }
1746
1747 struct fstContext *fstfile = nullptr;
1748 std::map<int,fstHandle> mapping;
1749 };
1750
1751 struct AIWWriter : public OutputWriter
1752 {
1753 AIWWriter(SimWorker *worker, std::string filename) : OutputWriter(worker) {
1754 aiwfile.open(filename.c_str());
1755 }
1756
1757 virtual ~AIWWriter()
1758 {
1759 aiwfile << '.' << '\n';
1760 }
1761
1762 void write(std::map<int, bool> &) override
1763 {
1764 if (!aiwfile.is_open()) return;
1765 if (worker->map_filename.empty())
1766 log_cmd_error("For AIGER witness file map parameter is mandatory.\n");
1767
1768 std::ifstream mf(worker->map_filename);
1769 std::string type, symbol;
1770 int variable, index;
1771 if (mf.fail())
1772 log_cmd_error("Not able to read AIGER witness map file.\n");
1773 while (mf >> type >> variable >> index >> symbol) {
1774 RTLIL::IdString escaped_s = RTLIL::escape_id(symbol);
1775 Wire *w = worker->top->module->wire(escaped_s);
1776 if (!w)
1777 log_error("Wire %s not present in module %s\n",log_id(escaped_s),log_id(worker->top->module));
1778 if (index < w->start_offset || index > w->start_offset + w->width)
1779 log_error("Index %d for wire %s is out of range\n", index, log_signal(w));
1780 if (type == "input") {
1781 aiw_inputs[variable] = SigBit(w,index-w->start_offset);
1782 } else if (type == "init") {
1783 aiw_inits[variable] = SigBit(w,index-w->start_offset);
1784 } else if (type == "latch") {
1785 aiw_latches[variable] = {SigBit(w,index-w->start_offset), false};
1786 } else if (type == "invlatch") {
1787 aiw_latches[variable] = {SigBit(w,index-w->start_offset), true};
1788 }
1789 }
1790
1791 worker->top->write_output_header(
1792 [](IdString) {},
1793 []() {},
1794 [this](Wire *wire, int id, bool) { mapping[wire] = id; }
1795 );
1796
1797 std::map<int, Yosys::RTLIL::Const> current;
1798 bool first = true;
1799 for(auto& d : worker->output_data)
1800 {
1801 for (auto &data : d.second)
1802 {
1803 current[data.first] = data.second;
1804 }
1805 if (first) {
1806 for (int i = 0;; i++)
1807 {
1808 if (aiw_latches.count(i)) {
1809 SigBit bit = aiw_latches.at(i).first;
1810 auto v = current[mapping[bit.wire]].bits.at(bit.offset);
1811 if (v == State::S1)
1812 aiwfile << (aiw_latches.at(i).second ? '0' : '1');
1813 else
1814 aiwfile << (aiw_latches.at(i).second ? '1' : '0');
1815 continue;
1816 }
1817 aiwfile << '\n';
1818 break;
1819 }
1820 first = false;
1821 }
1822
1823 for (int i = 0;; i++)
1824 {
1825 if (aiw_inputs.count(i)) {
1826 SigBit bit = aiw_inputs.at(i);
1827 auto v = current[mapping[bit.wire]].bits.at(bit.offset);
1828 if (v == State::S1)
1829 aiwfile << '1';
1830 else
1831 aiwfile << '0';
1832 continue;
1833 }
1834 if (aiw_inits.count(i)) {
1835 SigBit bit = aiw_inits.at(i);
1836 auto v = current[mapping[bit.wire]].bits.at(bit.offset);
1837 if (v == State::S1)
1838 aiwfile << '1';
1839 else
1840 aiwfile << '0';
1841 continue;
1842 }
1843 aiwfile << '\n';
1844 break;
1845 }
1846 }
1847 }
1848
1849 std::ofstream aiwfile;
1850 dict<int, std::pair<SigBit, bool>> aiw_latches;
1851 dict<int, SigBit> aiw_inputs, aiw_inits;
1852 std::map<Wire*,int> mapping;
1853 };
1854
1855 struct SimPass : public Pass {
1856 SimPass() : Pass("sim", "simulate the circuit") { }
1857 void help() override
1858 {
1859 // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
1860 log("\n");
1861 log(" sim [options] [top-level]\n");
1862 log("\n");
1863 log("This command simulates the circuit using the given top-level module.\n");
1864 log("\n");
1865 log(" -vcd <filename>\n");
1866 log(" write the simulation results to the given VCD file\n");
1867 log("\n");
1868 log(" -fst <filename>\n");
1869 log(" write the simulation results to the given FST file\n");
1870 log("\n");
1871 log(" -aiw <filename>\n");
1872 log(" write the simulation results to an AIGER witness file\n");
1873 log(" (requires a *.aim file via -map)\n");
1874 log("\n");
1875 log(" -x\n");
1876 log(" ignore constant x outputs in simulation file.\n");
1877 log("\n");
1878 log(" -date\n");
1879 log(" include date and full version info in output.\n");
1880 log("\n");
1881 log(" -clock <portname>\n");
1882 log(" name of top-level clock input\n");
1883 log("\n");
1884 log(" -clockn <portname>\n");
1885 log(" name of top-level clock input (inverse polarity)\n");
1886 log("\n");
1887 log(" -multiclock\n");
1888 log(" mark that witness file is multiclock.\n");
1889 log("\n");
1890 log(" -reset <portname>\n");
1891 log(" name of top-level reset input (active high)\n");
1892 log("\n");
1893 log(" -resetn <portname>\n");
1894 log(" name of top-level inverted reset input (active low)\n");
1895 log("\n");
1896 log(" -rstlen <integer>\n");
1897 log(" number of cycles reset should stay active (default: 1)\n");
1898 log("\n");
1899 log(" -zinit\n");
1900 log(" zero-initialize all uninitialized regs and memories\n");
1901 log("\n");
1902 log(" -timescale <string>\n");
1903 log(" include the specified timescale declaration in the vcd\n");
1904 log("\n");
1905 log(" -n <integer>\n");
1906 log(" number of clock cycles to simulate (default: 20)\n");
1907 log("\n");
1908 log(" -a\n");
1909 log(" use all nets in VCD/FST operations, not just those with public names\n");
1910 log("\n");
1911 log(" -w\n");
1912 log(" writeback mode: use final simulation state as new init state\n");
1913 log("\n");
1914 log(" -r\n");
1915 log(" read simulation results file (file formats supported: FST, VCD, AIW and WIT)\n");
1916 log(" VCD support requires vcd2fst external tool to be present\n");
1917 log("\n");
1918 log(" -map <filename>\n");
1919 log(" read file with port and latch symbols, needed for AIGER witness input\n");
1920 log("\n");
1921 log(" -scope <name>\n");
1922 log(" scope of simulation top model\n");
1923 log("\n");
1924 log(" -at <time>\n");
1925 log(" sets start and stop time\n");
1926 log("\n");
1927 log(" -start <time>\n");
1928 log(" start co-simulation in arbitary time (default 0)\n");
1929 log("\n");
1930 log(" -stop <time>\n");
1931 log(" stop co-simulation in arbitary time (default END)\n");
1932 log("\n");
1933 log(" -sim\n");
1934 log(" simulation with stimulus from FST (default)\n");
1935 log("\n");
1936 log(" -sim-cmp\n");
1937 log(" co-simulation expect exact match\n");
1938 log("\n");
1939 log(" -sim-gold\n");
1940 log(" co-simulation, x in simulation can match any value in FST\n");
1941 log("\n");
1942 log(" -sim-gate\n");
1943 log(" co-simulation, x in FST can match any value in simulation\n");
1944 log("\n");
1945 log(" -q\n");
1946 log(" disable per-cycle/sample log message\n");
1947 log("\n");
1948 log(" -d\n");
1949 log(" enable debug output\n");
1950 log("\n");
1951 }
1952
1953
1954 static std::string file_base_name(std::string const & path)
1955 {
1956 return path.substr(path.find_last_of("/\\") + 1);
1957 }
1958
1959 void execute(std::vector<std::string> args, RTLIL::Design *design) override
1960 {
1961 SimWorker worker;
1962 int numcycles = 20;
1963 bool start_set = false, stop_set = false, at_set = false;
1964
1965 log_header(design, "Executing SIM pass (simulate the circuit).\n");
1966
1967 size_t argidx;
1968 for (argidx = 1; argidx < args.size(); argidx++) {
1969 if (args[argidx] == "-vcd" && argidx+1 < args.size()) {
1970 std::string vcd_filename = args[++argidx];
1971 rewrite_filename(vcd_filename);
1972 worker.outputfiles.emplace_back(std::unique_ptr<VCDWriter>(new VCDWriter(&worker, vcd_filename.c_str())));
1973 continue;
1974 }
1975 if (args[argidx] == "-fst" && argidx+1 < args.size()) {
1976 std::string fst_filename = args[++argidx];
1977 rewrite_filename(fst_filename);
1978 worker.outputfiles.emplace_back(std::unique_ptr<FSTWriter>(new FSTWriter(&worker, fst_filename.c_str())));
1979 continue;
1980 }
1981 if (args[argidx] == "-aiw" && argidx+1 < args.size()) {
1982 std::string aiw_filename = args[++argidx];
1983 rewrite_filename(aiw_filename);
1984 worker.outputfiles.emplace_back(std::unique_ptr<AIWWriter>(new AIWWriter(&worker, aiw_filename.c_str())));
1985 continue;
1986 }
1987 if (args[argidx] == "-n" && argidx+1 < args.size()) {
1988 numcycles = atoi(args[++argidx].c_str());
1989 worker.cycles_set = true;
1990 continue;
1991 }
1992 if (args[argidx] == "-rstlen" && argidx+1 < args.size()) {
1993 worker.rstlen = atoi(args[++argidx].c_str());
1994 continue;
1995 }
1996 if (args[argidx] == "-clock" && argidx+1 < args.size()) {
1997 worker.clock.insert(RTLIL::escape_id(args[++argidx]));
1998 continue;
1999 }
2000 if (args[argidx] == "-clockn" && argidx+1 < args.size()) {
2001 worker.clockn.insert(RTLIL::escape_id(args[++argidx]));
2002 continue;
2003 }
2004 if (args[argidx] == "-reset" && argidx+1 < args.size()) {
2005 worker.reset.insert(RTLIL::escape_id(args[++argidx]));
2006 continue;
2007 }
2008 if (args[argidx] == "-resetn" && argidx+1 < args.size()) {
2009 worker.resetn.insert(RTLIL::escape_id(args[++argidx]));
2010 continue;
2011 }
2012 if (args[argidx] == "-timescale" && argidx+1 < args.size()) {
2013 worker.timescale = args[++argidx];
2014 continue;
2015 }
2016 if (args[argidx] == "-a") {
2017 worker.hide_internal = false;
2018 continue;
2019 }
2020 if (args[argidx] == "-q") {
2021 worker.verbose = false;
2022 continue;
2023 }
2024 if (args[argidx] == "-d") {
2025 worker.debug = true;
2026 continue;
2027 }
2028 if (args[argidx] == "-w") {
2029 worker.writeback = true;
2030 continue;
2031 }
2032 if (args[argidx] == "-zinit") {
2033 worker.zinit = true;
2034 continue;
2035 }
2036 if (args[argidx] == "-r" && argidx+1 < args.size()) {
2037 std::string sim_filename = args[++argidx];
2038 rewrite_filename(sim_filename);
2039 worker.sim_filename = sim_filename;
2040 continue;
2041 }
2042 if (args[argidx] == "-map" && argidx+1 < args.size()) {
2043 std::string map_filename = args[++argidx];
2044 rewrite_filename(map_filename);
2045 worker.map_filename = map_filename;
2046 continue;
2047 }
2048 if (args[argidx] == "-scope" && argidx+1 < args.size()) {
2049 worker.scope = args[++argidx];
2050 continue;
2051 }
2052 if (args[argidx] == "-start" && argidx+1 < args.size()) {
2053 worker.start_time = stringToTime(args[++argidx]);
2054 start_set = true;
2055 continue;
2056 }
2057 if (args[argidx] == "-stop" && argidx+1 < args.size()) {
2058 worker.stop_time = stringToTime(args[++argidx]);
2059 stop_set = true;
2060 continue;
2061 }
2062 if (args[argidx] == "-at" && argidx+1 < args.size()) {
2063 worker.start_time = stringToTime(args[++argidx]);
2064 worker.stop_time = worker.start_time;
2065 at_set = true;
2066 continue;
2067 }
2068 if (args[argidx] == "-sim") {
2069 worker.sim_mode = SimulationMode::sim;
2070 continue;
2071 }
2072 if (args[argidx] == "-sim-cmp") {
2073 worker.sim_mode = SimulationMode::cmp;
2074 continue;
2075 }
2076 if (args[argidx] == "-sim-gold") {
2077 worker.sim_mode = SimulationMode::gold;
2078 continue;
2079 }
2080 if (args[argidx] == "-sim-gate") {
2081 worker.sim_mode = SimulationMode::gate;
2082 continue;
2083 }
2084 if (args[argidx] == "-x") {
2085 worker.ignore_x = true;
2086 continue;
2087 }
2088 if (args[argidx] == "-date") {
2089 worker.date = true;
2090 continue;
2091 }
2092 if (args[argidx] == "-multiclock") {
2093 worker.multiclock = true;
2094 continue;
2095 }
2096 break;
2097 }
2098 extra_args(args, argidx, design);
2099 if (at_set && (start_set || stop_set || worker.cycles_set))
2100 log_error("'at' option can only be defined separate of 'start','stop' and 'n'\n");
2101 if (stop_set && worker.cycles_set)
2102 log_error("'stop' and 'n' can only be used exclusively'\n");
2103
2104 Module *top_mod = nullptr;
2105
2106 if (design->full_selection()) {
2107 top_mod = design->top_module();
2108
2109 if (!top_mod)
2110 log_cmd_error("Design has no top module, use the 'hierarchy' command to specify one.\n");
2111 } else {
2112 auto mods = design->selected_whole_modules();
2113 if (GetSize(mods) != 1)
2114 log_cmd_error("Only one top module must be selected.\n");
2115 top_mod = mods.front();
2116 }
2117
2118 if (worker.sim_filename.empty())
2119 worker.run(top_mod, numcycles);
2120 else {
2121 std::string filename_trim = file_base_name(worker.sim_filename);
2122 if (filename_trim.size() > 4 && ((filename_trim.compare(filename_trim.size()-4, std::string::npos, ".fst") == 0) ||
2123 filename_trim.compare(filename_trim.size()-4, std::string::npos, ".vcd") == 0)) {
2124 worker.run_cosim_fst(top_mod, numcycles);
2125 } else if (filename_trim.size() > 4 && filename_trim.compare(filename_trim.size()-4, std::string::npos, ".aiw") == 0) {
2126 if (worker.map_filename.empty())
2127 log_cmd_error("For AIGER witness file map parameter is mandatory.\n");
2128 worker.run_cosim_aiger_witness(top_mod);
2129 } else if (filename_trim.size() > 4 && filename_trim.compare(filename_trim.size()-4, std::string::npos, ".wit") == 0) {
2130 worker.run_cosim_btor2_witness(top_mod);
2131 } else {
2132 log_cmd_error("Unhandled extension for simulation input file `%s`.\n", worker.sim_filename.c_str());
2133 }
2134 }
2135 }
2136 } SimPass;
2137
2138 struct Fst2TbPass : public Pass {
2139 Fst2TbPass() : Pass("fst2tb", "generate testbench out of fst file") { }
2140 void help() override
2141 {
2142 // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
2143 log("\n");
2144 log(" fst2tb [options] [top-level]\n");
2145 log("\n");
2146 log("This command generates testbench for the circuit using the given top-level module\n");
2147 log("and simulus signal from FST file\n");
2148 log("\n");
2149 log(" -tb <name>\n");
2150 log(" generated testbench name.\n");
2151 log(" files <name>.v and <name>.txt are created as result.\n");
2152 log("\n");
2153 log(" -r <filename>\n");
2154 log(" read simulation FST file\n");
2155 log("\n");
2156 log(" -clock <portname>\n");
2157 log(" name of top-level clock input\n");
2158 log("\n");
2159 log(" -clockn <portname>\n");
2160 log(" name of top-level clock input (inverse polarity)\n");
2161 log("\n");
2162 log(" -scope <name>\n");
2163 log(" scope of simulation top model\n");
2164 log("\n");
2165 log(" -start <time>\n");
2166 log(" start co-simulation in arbitary time (default 0)\n");
2167 log("\n");
2168 log(" -stop <time>\n");
2169 log(" stop co-simulation in arbitary time (default END)\n");
2170 log("\n");
2171 log(" -n <integer>\n");
2172 log(" number of clock cycles to simulate (default: 20)\n");
2173 log("\n");
2174 }
2175
2176 void execute(std::vector<std::string> args, RTLIL::Design *design) override
2177 {
2178 SimWorker worker;
2179 int numcycles = 20;
2180 bool stop_set = false;
2181 std::string tb_filename;
2182
2183 log_header(design, "Executing FST2FB pass.\n");
2184
2185 size_t argidx;
2186 for (argidx = 1; argidx < args.size(); argidx++) {
2187 if (args[argidx] == "-clock" && argidx+1 < args.size()) {
2188 worker.clock.insert(RTLIL::escape_id(args[++argidx]));
2189 continue;
2190 }
2191 if (args[argidx] == "-clockn" && argidx+1 < args.size()) {
2192 worker.clockn.insert(RTLIL::escape_id(args[++argidx]));
2193 continue;
2194 }
2195 if (args[argidx] == "-r" && argidx+1 < args.size()) {
2196 std::string sim_filename = args[++argidx];
2197 rewrite_filename(sim_filename);
2198 worker.sim_filename = sim_filename;
2199 continue;
2200 }
2201 if (args[argidx] == "-n" && argidx+1 < args.size()) {
2202 numcycles = atoi(args[++argidx].c_str());
2203 worker.cycles_set = true;
2204 continue;
2205 }
2206 if (args[argidx] == "-scope" && argidx+1 < args.size()) {
2207 worker.scope = args[++argidx];
2208 continue;
2209 }
2210 if (args[argidx] == "-start" && argidx+1 < args.size()) {
2211 worker.start_time = stringToTime(args[++argidx]);
2212 continue;
2213 }
2214 if (args[argidx] == "-stop" && argidx+1 < args.size()) {
2215 worker.stop_time = stringToTime(args[++argidx]);
2216 stop_set = true;
2217 continue;
2218 }
2219 if (args[argidx] == "-tb" && argidx+1 < args.size()) {
2220 tb_filename = args[++argidx];
2221 continue;
2222 }
2223 break;
2224 }
2225 extra_args(args, argidx, design);
2226 if (stop_set && worker.cycles_set)
2227 log_error("'stop' and 'n' can only be used exclusively'\n");
2228
2229 Module *top_mod = nullptr;
2230
2231 if (design->full_selection()) {
2232 top_mod = design->top_module();
2233
2234 if (!top_mod)
2235 log_cmd_error("Design has no top module, use the 'hierarchy' command to specify one.\n");
2236 } else {
2237 auto mods = design->selected_whole_modules();
2238 if (GetSize(mods) != 1)
2239 log_cmd_error("Only one top module must be selected.\n");
2240 top_mod = mods.front();
2241 }
2242
2243 if (tb_filename.empty())
2244 log_cmd_error("Testbench name must be defined.\n");
2245
2246 if (worker.sim_filename.empty())
2247 log_cmd_error("Stimulus FST file must be defined.\n");
2248
2249 worker.generate_tb(top_mod, tb_filename, numcycles);
2250 }
2251 } Fst2TbPass;
2252
2253 PRIVATE_NAMESPACE_END