1 /* -*- c++ -*-
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
22 #ifndef RTLIL_H
23 #define RTLIL_H
24
25 YOSYS_NAMESPACE_BEGIN
26
27 namespace RTLIL
28 {
29 enum State : unsigned char {
30 S0 = 0,
31 S1 = 1,
32 Sx = 2, // undefined value or conflict
33 Sz = 3, // high-impedance / not-connected
34 Sa = 4, // don't care (used only in cases)
35 Sm = 5 // marker (used internally by some passes)
36 };
37
38 enum SyncType : unsigned char {
39 ST0 = 0, // level sensitive: 0
40 ST1 = 1, // level sensitive: 1
41 STp = 2, // edge sensitive: posedge
42 STn = 3, // edge sensitive: negedge
43 STe = 4, // edge sensitive: both edges
44 STa = 5, // always active
45 STg = 6, // global clock
46 STi = 7 // init
47 };
48
49 enum ConstFlags : unsigned char {
50 CONST_FLAG_NONE = 0,
51 CONST_FLAG_STRING = 1,
52 CONST_FLAG_SIGNED = 2, // only used for parameters
53 CONST_FLAG_REAL = 4 // only used for parameters
54 };
55
56 struct Const;
57 struct AttrObject;
58 struct Selection;
59 struct Monitor;
60 struct Design;
61 struct Module;
62 struct Wire;
63 struct Memory;
64 struct Cell;
65 struct SigChunk;
66 struct SigBit;
67 struct SigSpecIterator;
68 struct SigSpecConstIterator;
69 struct SigSpec;
70 struct CaseRule;
71 struct SwitchRule;
72 struct MemWriteAction;
73 struct SyncRule;
74 struct Process;
75 struct Binding;
76
77 typedef std::pair<SigSpec, SigSpec> SigSig;
78
79 struct IdString
80 {
81 #undef YOSYS_XTRACE_GET_PUT
82 #undef YOSYS_SORT_ID_FREE_LIST
83 #undef YOSYS_USE_STICKY_IDS
84 #undef YOSYS_NO_IDS_REFCNT
85
86 // the global id string cache
87
88 static struct destruct_guard_t {
89 bool ok; // POD, will be initialized to zero
destruct_guard_tIdString::destruct_guard_t90 destruct_guard_t() { ok = true; }
~destruct_guard_tIdString::destruct_guard_t91 ~destruct_guard_t() { ok = false; }
92 } destruct_guard;
93
94 static std::vector<char*> global_id_storage_;
95 static dict<char*, int, hash_cstr_ops> global_id_index_;
96 #ifndef YOSYS_NO_IDS_REFCNT
97 static std::vector<int> global_refcount_storage_;
98 static std::vector<int> global_free_idx_list_;
99 #endif
100
101 #ifdef YOSYS_USE_STICKY_IDS
102 static int last_created_idx_ptr_;
103 static int last_created_idx_[8];
104 #endif
105
xtrace_db_dumpIdString106 static inline void xtrace_db_dump()
107 {
108 #ifdef YOSYS_XTRACE_GET_PUT
109 for (int idx = 0; idx < GetSize(global_id_storage_); idx++)
110 {
111 if (global_id_storage_.at(idx) == nullptr)
112 log("#X# DB-DUMP index %d: FREE\n", idx);
113 else
114 log("#X# DB-DUMP index %d: '%s' (ref %d)\n", idx, global_id_storage_.at(idx), global_refcount_storage_.at(idx));
115 }
116 #endif
117 }
118
checkpointIdString119 static inline void checkpoint()
120 {
121 #ifdef YOSYS_USE_STICKY_IDS
122 last_created_idx_ptr_ = 0;
123 for (int i = 0; i < 8; i++) {
124 if (last_created_idx_[i])
125 put_reference(last_created_idx_[i]);
126 last_created_idx_[i] = 0;
127 }
128 #endif
129 #ifdef YOSYS_SORT_ID_FREE_LIST
130 std::sort(global_free_idx_list_.begin(), global_free_idx_list_.end(), std::greater<int>());
131 #endif
132 }
133
get_referenceIdString134 static inline int get_reference(int idx)
135 {
136 if (idx) {
137 #ifndef YOSYS_NO_IDS_REFCNT
138 global_refcount_storage_[idx]++;
139 #endif
140 #ifdef YOSYS_XTRACE_GET_PUT
141 if (yosys_xtrace)
142 log("#X# GET-BY-INDEX '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
143 #endif
144 }
145 return idx;
146 }
147
get_referenceIdString148 static int get_reference(const char *p)
149 {
150 log_assert(destruct_guard.ok);
151
152 if (!p[0])
153 return 0;
154
155 auto it = global_id_index_.find((char*)p);
156 if (it != global_id_index_.end()) {
157 #ifndef YOSYS_NO_IDS_REFCNT
158 global_refcount_storage_.at(it->second)++;
159 #endif
160 #ifdef YOSYS_XTRACE_GET_PUT
161 if (yosys_xtrace)
162 log("#X# GET-BY-NAME '%s' (index %d, refcount %d)\n", global_id_storage_.at(it->second), it->second, global_refcount_storage_.at(it->second));
163 #endif
164 return it->second;
165 }
166
167 log_assert(p[0] == '$' || p[0] == '\\');
168 log_assert(p[1] != 0);
169 for (const char *c = p; *c; c++)
170 if ((unsigned)*c <= (unsigned)' ')
171 log_error("Found control character or space (0x%02hhx) in string '%s' which is not allowed in RTLIL identifiers\n", *c, p);
172
173 #ifndef YOSYS_NO_IDS_REFCNT
174 if (global_free_idx_list_.empty()) {
175 if (global_id_storage_.empty()) {
176 global_refcount_storage_.push_back(0);
177 global_id_storage_.push_back((char*)"");
178 global_id_index_[global_id_storage_.back()] = 0;
179 }
180 log_assert(global_id_storage_.size() < 0x40000000);
181 global_free_idx_list_.push_back(global_id_storage_.size());
182 global_id_storage_.push_back(nullptr);
183 global_refcount_storage_.push_back(0);
184 }
185
186 int idx = global_free_idx_list_.back();
187 global_free_idx_list_.pop_back();
188 global_id_storage_.at(idx) = strdup(p);
189 global_id_index_[global_id_storage_.at(idx)] = idx;
190 global_refcount_storage_.at(idx)++;
191 #else
192 if (global_id_storage_.empty()) {
193 global_id_storage_.push_back((char*)"");
194 global_id_index_[global_id_storage_.back()] = 0;
195 }
196 int idx = global_id_storage_.size();
197 global_id_storage_.push_back(strdup(p));
198 global_id_index_[global_id_storage_.back()] = idx;
199 #endif
200
201 if (yosys_xtrace) {
202 log("#X# New IdString '%s' with index %d.\n", p, idx);
203 log_backtrace("-X- ", yosys_xtrace-1);
204 }
205
206 #ifdef YOSYS_XTRACE_GET_PUT
207 if (yosys_xtrace)
208 log("#X# GET-BY-NAME '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
209 #endif
210
211 #ifdef YOSYS_USE_STICKY_IDS
212 // Avoid Create->Delete->Create pattern
213 if (last_created_idx_[last_created_idx_ptr_])
214 put_reference(last_created_idx_[last_created_idx_ptr_]);
215 last_created_idx_[last_created_idx_ptr_] = idx;
216 get_reference(last_created_idx_[last_created_idx_ptr_]);
217 last_created_idx_ptr_ = (last_created_idx_ptr_ + 1) & 7;
218 #endif
219
220 return idx;
221 }
222
223 #ifndef YOSYS_NO_IDS_REFCNT
put_referenceIdString224 static inline void put_reference(int idx)
225 {
226 // put_reference() may be called from destructors after the destructor of
227 // global_refcount_storage_ has been run. in this case we simply do nothing.
228 if (!destruct_guard.ok || !idx)
229 return;
230
231 #ifdef YOSYS_XTRACE_GET_PUT
232 if (yosys_xtrace) {
233 log("#X# PUT '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
234 }
235 #endif
236
237 int &refcount = global_refcount_storage_[idx];
238
239 if (--refcount > 0)
240 return;
241
242 log_assert(refcount == 0);
243 free_reference(idx);
244 }
free_referenceIdString245 static inline void free_reference(int idx)
246 {
247 if (yosys_xtrace) {
248 log("#X# Removed IdString '%s' with index %d.\n", global_id_storage_.at(idx), idx);
249 log_backtrace("-X- ", yosys_xtrace-1);
250 }
251
252 global_id_index_.erase(global_id_storage_.at(idx));
253 free(global_id_storage_.at(idx));
254 global_id_storage_.at(idx) = nullptr;
255 global_free_idx_list_.push_back(idx);
256 }
257 #else
put_referenceIdString258 static inline void put_reference(int) { }
259 #endif
260
261 // the actual IdString object is just is a single int
262
263 int index_;
264
IdStringIdString265 inline IdString() : index_(0) { }
IdStringIdString266 inline IdString(const char *str) : index_(get_reference(str)) { }
IdStringIdString267 inline IdString(const IdString &str) : index_(get_reference(str.index_)) { }
IdStringIdString268 inline IdString(IdString &&str) : index_(str.index_) { str.index_ = 0; }
IdStringIdString269 inline IdString(const std::string &str) : index_(get_reference(str.c_str())) { }
~IdStringIdString270 inline ~IdString() { put_reference(index_); }
271
272 inline void operator=(const IdString &rhs) {
273 put_reference(index_);
274 index_ = get_reference(rhs.index_);
275 }
276
277 inline void operator=(const char *rhs) {
278 IdString id(rhs);
279 *this = id;
280 }
281
282 inline void operator=(const std::string &rhs) {
283 IdString id(rhs);
284 *this = id;
285 }
286
c_strIdString287 inline const char *c_str() const {
288 return global_id_storage_.at(index_);
289 }
290
strIdString291 inline std::string str() const {
292 return std::string(global_id_storage_.at(index_));
293 }
294
295 inline bool operator<(const IdString &rhs) const {
296 return index_ < rhs.index_;
297 }
298
299 inline bool operator==(const IdString &rhs) const { return index_ == rhs.index_; }
300 inline bool operator!=(const IdString &rhs) const { return index_ != rhs.index_; }
301
302 // The methods below are just convenience functions for better compatibility with std::string.
303
304 bool operator==(const std::string &rhs) const { return c_str() == rhs; }
305 bool operator!=(const std::string &rhs) const { return c_str() != rhs; }
306
307 bool operator==(const char *rhs) const { return strcmp(c_str(), rhs) == 0; }
308 bool operator!=(const char *rhs) const { return strcmp(c_str(), rhs) != 0; }
309
310 char operator[](size_t i) const {
311 const char *p = c_str();
312 for (; i != 0; i--, p++)
313 log_assert(*p != 0);
314 return *p;
315 }
316
317 std::string substr(size_t pos = 0, size_t len = std::string::npos) const {
318 if (len == std::string::npos || len >= strlen(c_str() + pos))
319 return std::string(c_str() + pos);
320 else
321 return std::string(c_str() + pos, len);
322 }
323
compareIdString324 int compare(size_t pos, size_t len, const char* s) const {
325 return strncmp(c_str()+pos, s, len);
326 }
327
begins_withIdString328 bool begins_with(const char* prefix) const {
329 size_t len = strlen(prefix);
330 if (size() < len) return false;
331 return compare(0, len, prefix) == 0;
332 }
333
ends_withIdString334 bool ends_with(const char* suffix) const {
335 size_t len = strlen(suffix);
336 if (size() < len) return false;
337 return compare(size()-len, len, suffix) == 0;
338 }
339
containsIdString340 bool contains(const char* str) const {
341 return strstr(c_str(), str);
342 }
343
sizeIdString344 size_t size() const {
345 return strlen(c_str());
346 }
347
emptyIdString348 bool empty() const {
349 return c_str()[0] == 0;
350 }
351
clearIdString352 void clear() {
353 *this = IdString();
354 }
355
hashIdString356 unsigned int hash() const {
357 return index_;
358 }
359
360 // The following is a helper key_compare class. Instead of for example std::set<Cell*>
361 // use std::set<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the
362 // set has an influence on the algorithm.
363
364 template<typename T> struct compare_ptr_by_name {
operatorIdString::compare_ptr_by_name365 bool operator()(const T *a, const T *b) const {
366 return (a == nullptr || b == nullptr) ? (a < b) : (a->name < b->name);
367 }
368 };
369
370 // often one needs to check if a given IdString is part of a list (for example a list
371 // of cell types). the following functions helps with that.
372
373 template<typename... Args>
inIdString374 bool in(Args... args) const {
375 // Credit: https://articles.emptycrate.com/2016/05/14/folds_in_cpp11_ish.html
376 bool result = false;
377 (void) std::initializer_list<int>{ (result = result || in(args), 0)... };
378 return result;
379 }
380
inIdString381 bool in(const IdString &rhs) const { return *this == rhs; }
inIdString382 bool in(const char *rhs) const { return *this == rhs; }
inIdString383 bool in(const std::string &rhs) const { return *this == rhs; }
inIdString384 bool in(const pool<IdString> &rhs) const { return rhs.count(*this) != 0; }
385
isPublicIdString386 bool isPublic() const { return begins_with("\\"); }
387 };
388
389 namespace ID {
390 #define X(_id) extern IdString _id;
391 #include "kernel/constids.inc"
392 #undef X
393 };
394
395 extern dict<std::string, std::string> constpad;
396
397 const pool<IdString> &builtin_ff_cell_types();
398
escape_id(const std::string & str)399 static inline std::string escape_id(const std::string &str) {
400 if (str.size() > 0 && str[0] != '\\' && str[0] != '$')
401 return "\\" + str;
402 return str;
403 }
404
unescape_id(const std::string & str)405 static inline std::string unescape_id(const std::string &str) {
406 if (str.size() < 2)
407 return str;
408 if (str[0] != '\\')
409 return str;
410 if (str[1] == '$' || str[1] == '\\')
411 return str;
412 if (str[1] >= '0' && str[1] <= '9')
413 return str;
414 return str.substr(1);
415 }
416
unescape_id(RTLIL::IdString str)417 static inline std::string unescape_id(RTLIL::IdString str) {
418 return unescape_id(str.str());
419 }
420
id2cstr(RTLIL::IdString str)421 static inline const char *id2cstr(RTLIL::IdString str) {
422 return log_id(str);
423 }
424
425 template <typename T> struct sort_by_name_id {
operatorsort_by_name_id426 bool operator()(T *a, T *b) const {
427 return a->name < b->name;
428 }
429 };
430
431 template <typename T> struct sort_by_name_str {
operatorsort_by_name_str432 bool operator()(T *a, T *b) const {
433 return strcmp(a->name.c_str(), b->name.c_str()) < 0;
434 }
435 };
436
437 struct sort_by_id_str {
operatorsort_by_id_str438 bool operator()(RTLIL::IdString a, RTLIL::IdString b) const {
439 return strcmp(a.c_str(), b.c_str()) < 0;
440 }
441 };
442
443 // see calc.cc for the implementation of this functions
444 RTLIL::Const const_not (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
445 RTLIL::Const const_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
446 RTLIL::Const const_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
447 RTLIL::Const const_xor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
448 RTLIL::Const const_xnor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
449
450 RTLIL::Const const_reduce_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
451 RTLIL::Const const_reduce_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
452 RTLIL::Const const_reduce_xor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
453 RTLIL::Const const_reduce_xnor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
454 RTLIL::Const const_reduce_bool (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
455
456 RTLIL::Const const_logic_not (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
457 RTLIL::Const const_logic_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
458 RTLIL::Const const_logic_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
459
460 RTLIL::Const const_shl (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
461 RTLIL::Const const_shr (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
462 RTLIL::Const const_sshl (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
463 RTLIL::Const const_sshr (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
464 RTLIL::Const const_shift (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
465 RTLIL::Const const_shiftx (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
466
467 RTLIL::Const const_lt (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
468 RTLIL::Const const_le (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
469 RTLIL::Const const_eq (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
470 RTLIL::Const const_ne (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
471 RTLIL::Const const_eqx (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
472 RTLIL::Const const_nex (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
473 RTLIL::Const const_ge (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
474 RTLIL::Const const_gt (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
475
476 RTLIL::Const const_add (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
477 RTLIL::Const const_sub (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
478 RTLIL::Const const_mul (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
479 RTLIL::Const const_div (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
480 RTLIL::Const const_divfloor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
481 RTLIL::Const const_modfloor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
482 RTLIL::Const const_mod (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
483 RTLIL::Const const_pow (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
484
485 RTLIL::Const const_pos (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
486 RTLIL::Const const_neg (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
487
488
489 // This iterator-range-pair is used for Design::modules(), Module::wires() and Module::cells().
490 // It maintains a reference counter that is used to make sure that the container is not modified while being iterated over.
491
492 template<typename T>
493 struct ObjIterator {
494 using iterator_category = std::forward_iterator_tag;
495 using value_type = T;
496 using difference_type = ptrdiff_t;
497 using pointer = T*;
498 using reference = T&;
499 typename dict<RTLIL::IdString, T>::iterator it;
500 dict<RTLIL::IdString, T> *list_p;
501 int *refcount_p;
502
ObjIteratorObjIterator503 ObjIterator() : list_p(nullptr), refcount_p(nullptr) {
504 }
505
ObjIteratorObjIterator506 ObjIterator(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) {
507 if (list_p->empty()) {
508 this->list_p = nullptr;
509 this->refcount_p = nullptr;
510 } else {
511 it = list_p->begin();
512 (*refcount_p)++;
513 }
514 }
515
ObjIteratorObjIterator516 ObjIterator(const RTLIL::ObjIterator<T> &other) {
517 it = other.it;
518 list_p = other.list_p;
519 refcount_p = other.refcount_p;
520 if (refcount_p)
521 (*refcount_p)++;
522 }
523
524 ObjIterator &operator=(const RTLIL::ObjIterator<T> &other) {
525 if (refcount_p)
526 (*refcount_p)--;
527 it = other.it;
528 list_p = other.list_p;
529 refcount_p = other.refcount_p;
530 if (refcount_p)
531 (*refcount_p)++;
532 return *this;
533 }
534
~ObjIteratorObjIterator535 ~ObjIterator() {
536 if (refcount_p)
537 (*refcount_p)--;
538 }
539
540 inline T operator*() const {
541 log_assert(list_p != nullptr);
542 return it->second;
543 }
544
545 inline bool operator!=(const RTLIL::ObjIterator<T> &other) const {
546 if (list_p == nullptr || other.list_p == nullptr)
547 return list_p != other.list_p;
548 return it != other.it;
549 }
550
551
552 inline bool operator==(const RTLIL::ObjIterator<T> &other) const {
553 return !(*this != other);
554 }
555
556 inline ObjIterator<T>& operator++() {
557 log_assert(list_p != nullptr);
558 if (++it == list_p->end()) {
559 (*refcount_p)--;
560 list_p = nullptr;
561 refcount_p = nullptr;
562 }
563 return *this;
564 }
565
566 inline ObjIterator<T>& operator+=(int amt) {
567 log_assert(list_p != nullptr);
568 it += amt;
569 if (it == list_p->end()) {
570 (*refcount_p)--;
571 list_p = nullptr;
572 refcount_p = nullptr;
573 }
574 return *this;
575 }
576
577 inline ObjIterator<T> operator+(int amt) {
578 log_assert(list_p != nullptr);
579 ObjIterator<T> new_obj(*this);
580 new_obj.it += amt;
581 if (new_obj.it == list_p->end()) {
582 (*(new_obj.refcount_p))--;
583 new_obj.list_p = nullptr;
584 new_obj.refcount_p = nullptr;
585 }
586 return new_obj;
587 }
588
589 inline const ObjIterator<T> operator++(int) {
590 ObjIterator<T> result(*this);
591 ++(*this);
592 return result;
593 }
594 };
595
596 template<typename T>
597 struct ObjRange
598 {
599 dict<RTLIL::IdString, T> *list_p;
600 int *refcount_p;
601
ObjRangeObjRange602 ObjRange(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) { }
beginObjRange603 RTLIL::ObjIterator<T> begin() { return RTLIL::ObjIterator<T>(list_p, refcount_p); }
endObjRange604 RTLIL::ObjIterator<T> end() { return RTLIL::ObjIterator<T>(); }
605
sizeObjRange606 size_t size() const {
607 return list_p->size();
608 }
609
610 operator pool<T>() const {
611 pool<T> result;
612 for (auto &it : *list_p)
613 result.insert(it.second);
614 return result;
615 }
616
617 operator std::vector<T>() const {
618 std::vector<T> result;
619 result.reserve(list_p->size());
620 for (auto &it : *list_p)
621 result.push_back(it.second);
622 return result;
623 }
624
to_poolObjRange625 pool<T> to_pool() const { return *this; }
to_vectorObjRange626 std::vector<T> to_vector() const { return *this; }
627 };
628 };
629
630 struct RTLIL::Const
631 {
632 int flags;
633 std::vector<RTLIL::State> bits;
634
635 Const();
636 Const(std::string str);
637 Const(int val, int width = 32);
638 Const(RTLIL::State bit, int width = 1);
ConstConst639 Const(const std::vector<RTLIL::State> &bits) : bits(bits) { flags = CONST_FLAG_NONE; }
640 Const(const std::vector<bool> &bits);
641 Const(const RTLIL::Const &c);
642 RTLIL::Const &operator =(const RTLIL::Const &other) = default;
643
644 bool operator <(const RTLIL::Const &other) const;
645 bool operator ==(const RTLIL::Const &other) const;
646 bool operator !=(const RTLIL::Const &other) const;
647
648 bool as_bool() const;
649 int as_int(bool is_signed = false) const;
650 std::string as_string() const;
651 static Const from_string(const std::string &str);
652
653 std::string decode_string() const;
654
sizeConst655 inline int size() const { return bits.size(); }
emptyConst656 inline bool empty() const { return bits.empty(); }
657 inline RTLIL::State &operator[](int index) { return bits.at(index); }
658 inline const RTLIL::State &operator[](int index) const { return bits.at(index); }
decltypeConst659 inline decltype(bits)::iterator begin() { return bits.begin(); }
decltypeConst660 inline decltype(bits)::iterator end() { return bits.end(); }
661
662 bool is_fully_zero() const;
663 bool is_fully_ones() const;
664 bool is_fully_def() const;
665 bool is_fully_undef() const;
666 bool is_onehot(int *pos = nullptr) const;
667
668 inline RTLIL::Const extract(int offset, int len = 1, RTLIL::State padding = RTLIL::State::S0) const {
669 RTLIL::Const ret;
670 ret.bits.reserve(len);
671 for (int i = offset; i < offset + len; i++)
672 ret.bits.push_back(i < GetSize(bits) ? bits[i] : padding);
673 return ret;
674 }
675
extuConst676 void extu(int width) {
677 bits.resize(width, RTLIL::State::S0);
678 }
679
extsConst680 void exts(int width) {
681 bits.resize(width, bits.empty() ? RTLIL::State::Sx : bits.back());
682 }
683
hashConst684 inline unsigned int hash() const {
685 unsigned int h = mkhash_init;
686 for (auto b : bits)
687 mkhash(h, b);
688 return h;
689 }
690 };
691
692 struct RTLIL::AttrObject
693 {
694 dict<RTLIL::IdString, RTLIL::Const> attributes;
695
696 bool has_attribute(RTLIL::IdString id) const;
697
698 void set_bool_attribute(RTLIL::IdString id, bool value=true);
699 bool get_bool_attribute(RTLIL::IdString id) const;
700
701 bool get_blackbox_attribute(bool ignore_wb=false) const {
702 return get_bool_attribute(ID::blackbox) || (!ignore_wb && get_bool_attribute(ID::whitebox));
703 }
704
705 void set_string_attribute(RTLIL::IdString id, string value);
706 string get_string_attribute(RTLIL::IdString id) const;
707
708 void set_strpool_attribute(RTLIL::IdString id, const pool<string> &data);
709 void add_strpool_attribute(RTLIL::IdString id, const pool<string> &data);
710 pool<string> get_strpool_attribute(RTLIL::IdString id) const;
711
set_src_attributeAttrObject712 void set_src_attribute(const std::string &src) {
713 set_string_attribute(ID::src, src);
714 }
get_src_attributeAttrObject715 std::string get_src_attribute() const {
716 return get_string_attribute(ID::src);
717 }
718
719 void set_hdlname_attribute(const vector<string> &hierarchy);
720 vector<string> get_hdlname_attribute() const;
721
722 void set_intvec_attribute(RTLIL::IdString id, const vector<int> &data);
723 vector<int> get_intvec_attribute(RTLIL::IdString id) const;
724 };
725
726 struct RTLIL::SigChunk
727 {
728 RTLIL::Wire *wire;
729 std::vector<RTLIL::State> data; // only used if wire == NULL, LSB at index 0
730 int width, offset;
731
732 SigChunk();
733 SigChunk(const RTLIL::Const &value);
734 SigChunk(RTLIL::Wire *wire);
735 SigChunk(RTLIL::Wire *wire, int offset, int width = 1);
736 SigChunk(const std::string &str);
737 SigChunk(int val, int width = 32);
738 SigChunk(RTLIL::State bit, int width = 1);
739 SigChunk(const RTLIL::SigBit &bit);
740 SigChunk(const RTLIL::SigChunk &sigchunk);
741 RTLIL::SigChunk &operator =(const RTLIL::SigChunk &other) = default;
742
743 RTLIL::SigChunk extract(int offset, int length) const;
sizeSigChunk744 inline int size() const { return width; }
is_wireSigChunk745 inline bool is_wire() const { return wire != NULL; }
746
747 bool operator <(const RTLIL::SigChunk &other) const;
748 bool operator ==(const RTLIL::SigChunk &other) const;
749 bool operator !=(const RTLIL::SigChunk &other) const;
750 };
751
752 struct RTLIL::SigBit
753 {
754 RTLIL::Wire *wire;
755 union {
756 RTLIL::State data; // used if wire == NULL
757 int offset; // used if wire != NULL
758 };
759
760 SigBit();
761 SigBit(RTLIL::State bit);
762 explicit SigBit(bool bit);
763 SigBit(RTLIL::Wire *wire);
764 SigBit(RTLIL::Wire *wire, int offset);
765 SigBit(const RTLIL::SigChunk &chunk);
766 SigBit(const RTLIL::SigChunk &chunk, int index);
767 SigBit(const RTLIL::SigSpec &sig);
768 SigBit(const RTLIL::SigBit &sigbit) = default;
769 RTLIL::SigBit &operator =(const RTLIL::SigBit &other) = default;
770
is_wireSigBit771 inline bool is_wire() const { return wire != NULL; }
772
773 bool operator <(const RTLIL::SigBit &other) const;
774 bool operator ==(const RTLIL::SigBit &other) const;
775 bool operator !=(const RTLIL::SigBit &other) const;
776 unsigned int hash() const;
777 };
778
779 struct RTLIL::SigSpecIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
780 {
781 RTLIL::SigSpec *sig_p;
782 int index;
783
784 inline RTLIL::SigBit &operator*() const;
785 inline bool operator!=(const RTLIL::SigSpecIterator &other) const { return index != other.index; }
786 inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
787 inline void operator++() { index++; }
788 };
789
790 struct RTLIL::SigSpecConstIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
791 {
792 const RTLIL::SigSpec *sig_p;
793 int index;
794
795 inline const RTLIL::SigBit &operator*() const;
796 inline bool operator!=(const RTLIL::SigSpecConstIterator &other) const { return index != other.index; }
797 inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
798 inline void operator++() { index++; }
799 };
800
801 struct RTLIL::SigSpec
802 {
803 private:
804 int width_;
805 unsigned long hash_;
806 std::vector<RTLIL::SigChunk> chunks_; // LSB at index 0
807 std::vector<RTLIL::SigBit> bits_; // LSB at index 0
808
809 void pack() const;
810 void unpack() const;
811 void updhash() const;
812
packedSigSpec813 inline bool packed() const {
814 return bits_.empty();
815 }
816
inline_unpackSigSpec817 inline void inline_unpack() const {
818 if (!chunks_.empty())
819 unpack();
820 }
821
822 // Only used by Module::remove(const pool<Wire*> &wires)
823 // but cannot be more specific as it isn't yet declared
824 friend struct RTLIL::Module;
825
826 public:
827 SigSpec();
828 SigSpec(const RTLIL::SigSpec &other);
829 SigSpec(std::initializer_list<RTLIL::SigSpec> parts);
830 RTLIL::SigSpec &operator=(const RTLIL::SigSpec &other);
831
832 SigSpec(const RTLIL::Const &value);
833 SigSpec(const RTLIL::SigChunk &chunk);
834 SigSpec(RTLIL::Wire *wire);
835 SigSpec(RTLIL::Wire *wire, int offset, int width = 1);
836 SigSpec(const std::string &str);
837 SigSpec(int val, int width = 32);
838 SigSpec(RTLIL::State bit, int width = 1);
839 SigSpec(const RTLIL::SigBit &bit, int width = 1);
840 SigSpec(const std::vector<RTLIL::SigChunk> &chunks);
841 SigSpec(const std::vector<RTLIL::SigBit> &bits);
842 SigSpec(const pool<RTLIL::SigBit> &bits);
843 SigSpec(const std::set<RTLIL::SigBit> &bits);
844 explicit SigSpec(bool bit);
845
SigSpecSigSpec846 SigSpec(RTLIL::SigSpec &&other) {
847 width_ = other.width_;
848 hash_ = other.hash_;
849 chunks_ = std::move(other.chunks_);
850 bits_ = std::move(other.bits_);
851 }
852
853 const RTLIL::SigSpec &operator=(RTLIL::SigSpec &&other) {
854 width_ = other.width_;
855 hash_ = other.hash_;
856 chunks_ = std::move(other.chunks_);
857 bits_ = std::move(other.bits_);
858 return *this;
859 }
860
get_hashSigSpec861 size_t get_hash() const {
862 if (!hash_) hash();
863 return hash_;
864 }
865
chunksSigSpec866 inline const std::vector<RTLIL::SigChunk> &chunks() const { pack(); return chunks_; }
bitsSigSpec867 inline const std::vector<RTLIL::SigBit> &bits() const { inline_unpack(); return bits_; }
868
sizeSigSpec869 inline int size() const { return width_; }
emptySigSpec870 inline bool empty() const { return width_ == 0; }
871
872 inline RTLIL::SigBit &operator[](int index) { inline_unpack(); return bits_.at(index); }
873 inline const RTLIL::SigBit &operator[](int index) const { inline_unpack(); return bits_.at(index); }
874
beginSigSpec875 inline RTLIL::SigSpecIterator begin() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = 0; return it; }
endSigSpec876 inline RTLIL::SigSpecIterator end() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = width_; return it; }
877
beginSigSpec878 inline RTLIL::SigSpecConstIterator begin() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = 0; return it; }
endSigSpec879 inline RTLIL::SigSpecConstIterator end() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = width_; return it; }
880
881 void sort();
882 void sort_and_unify();
883
884 void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with);
885 void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with, RTLIL::SigSpec *other) const;
886
887 void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules);
888 void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
889
890 void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules);
891 void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
892
893 void replace(int offset, const RTLIL::SigSpec &with);
894
895 void remove(const RTLIL::SigSpec &pattern);
896 void remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) const;
897 void remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other);
898
899 void remove(const pool<RTLIL::SigBit> &pattern);
900 void remove(const pool<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const;
901 void remove2(const pool<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
902 void remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
903
904 void remove(int offset, int length = 1);
905 void remove_const();
906
907 RTLIL::SigSpec extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other = NULL) const;
908 RTLIL::SigSpec extract(const pool<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other = NULL) const;
909 RTLIL::SigSpec extract(int offset, int length = 1) const;
extract_endSigSpec910 RTLIL::SigSpec extract_end(int offset) const { return extract(offset, width_ - offset); }
911
912 void append(const RTLIL::SigSpec &signal);
appendSigSpec913 inline void append(Wire *wire) { append(RTLIL::SigSpec(wire)); }
appendSigSpec914 inline void append(const RTLIL::SigChunk &chunk) { append(RTLIL::SigSpec(chunk)); }
appendSigSpec915 inline void append(const RTLIL::Const &const_) { append(RTLIL::SigSpec(const_)); }
916
917 void append(const RTLIL::SigBit &bit);
appendSigSpec918 inline void append(RTLIL::State state) { append(RTLIL::SigBit(state)); }
appendSigSpec919 inline void append(bool bool_) { append(RTLIL::SigBit(bool_)); }
920
921 void extend_u0(int width, bool is_signed = false);
922
923 RTLIL::SigSpec repeat(int num) const;
924
reverseSigSpec925 void reverse() { inline_unpack(); std::reverse(bits_.begin(), bits_.end()); }
926
927 bool operator <(const RTLIL::SigSpec &other) const;
928 bool operator ==(const RTLIL::SigSpec &other) const;
929 inline bool operator !=(const RTLIL::SigSpec &other) const { return !(*this == other); }
930
931 bool is_wire() const;
932 bool is_chunk() const;
is_bitSigSpec933 inline bool is_bit() const { return width_ == 1; }
934
935 bool is_fully_const() const;
936 bool is_fully_zero() const;
937 bool is_fully_ones() const;
938 bool is_fully_def() const;
939 bool is_fully_undef() const;
940 bool has_const() const;
941 bool has_marked_bits() const;
942 bool is_onehot(int *pos = nullptr) const;
943
944 bool as_bool() const;
945 int as_int(bool is_signed = false) const;
946 std::string as_string() const;
947 RTLIL::Const as_const() const;
948 RTLIL::Wire *as_wire() const;
949 RTLIL::SigChunk as_chunk() const;
950 RTLIL::SigBit as_bit() const;
951
952 bool match(const char* pattern) const;
953
954 std::set<RTLIL::SigBit> to_sigbit_set() const;
955 pool<RTLIL::SigBit> to_sigbit_pool() const;
956 std::vector<RTLIL::SigBit> to_sigbit_vector() const;
957 std::map<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_map(const RTLIL::SigSpec &other) const;
958 dict<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_dict(const RTLIL::SigSpec &other) const;
959
960 static bool parse(RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
961 static bool parse_sel(RTLIL::SigSpec &sig, RTLIL::Design *design, RTLIL::Module *module, std::string str);
962 static bool parse_rhs(const RTLIL::SigSpec &lhs, RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
963
964 operator std::vector<RTLIL::SigChunk>() const { return chunks(); }
965 operator std::vector<RTLIL::SigBit>() const { return bits(); }
atSigSpec966 const RTLIL::SigBit &at(int offset, const RTLIL::SigBit &defval) { return offset < width_ ? (*this)[offset] : defval; }
967
hashSigSpec968 unsigned int hash() const { if (!hash_) updhash(); return hash_; };
969
970 #ifndef NDEBUG
971 void check(Module *mod = nullptr) const;
972 #else
973 void check(Module *mod = nullptr) const { }
974 #endif
975 };
976
977 struct RTLIL::Selection
978 {
979 bool full_selection;
980 pool<RTLIL::IdString> selected_modules;
981 dict<RTLIL::IdString, pool<RTLIL::IdString>> selected_members;
982
full_selectionSelection983 Selection(bool full = true) : full_selection(full) { }
984
985 bool selected_module(RTLIL::IdString mod_name) const;
986 bool selected_whole_module(RTLIL::IdString mod_name) const;
987 bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
988 void optimize(RTLIL::Design *design);
989
selectSelection990 template<typename T1> void select(T1 *module) {
991 if (!full_selection && selected_modules.count(module->name) == 0) {
992 selected_modules.insert(module->name);
993 selected_members.erase(module->name);
994 }
995 }
996
selectSelection997 template<typename T1, typename T2> void select(T1 *module, T2 *member) {
998 if (!full_selection && selected_modules.count(module->name) == 0)
999 selected_members[module->name].insert(member->name);
1000 }
1001
emptySelection1002 bool empty() const {
1003 return !full_selection && selected_modules.empty() && selected_members.empty();
1004 }
1005 };
1006
1007 struct RTLIL::Monitor
1008 {
1009 unsigned int hashidx_;
hashMonitor1010 unsigned int hash() const { return hashidx_; }
1011
MonitorMonitor1012 Monitor() {
1013 static unsigned int hashidx_count = 123456789;
1014 hashidx_count = mkhash_xorshift(hashidx_count);
1015 hashidx_ = hashidx_count;
1016 }
1017
~MonitorMonitor1018 virtual ~Monitor() { }
notify_module_addMonitor1019 virtual void notify_module_add(RTLIL::Module*) { }
notify_module_delMonitor1020 virtual void notify_module_del(RTLIL::Module*) { }
notify_connectMonitor1021 virtual void notify_connect(RTLIL::Cell*, const RTLIL::IdString&, const RTLIL::SigSpec&, const RTLIL::SigSpec&) { }
notify_connectMonitor1022 virtual void notify_connect(RTLIL::Module*, const RTLIL::SigSig&) { }
notify_connectMonitor1023 virtual void notify_connect(RTLIL::Module*, const std::vector<RTLIL::SigSig>&) { }
notify_blackoutMonitor1024 virtual void notify_blackout(RTLIL::Module*) { }
1025 };
1026
1027 // Forward declaration; defined in preproc.h.
1028 struct define_map_t;
1029
1030 struct RTLIL::Design
1031 {
1032 unsigned int hashidx_;
hashDesign1033 unsigned int hash() const { return hashidx_; }
1034
1035 pool<RTLIL::Monitor*> monitors;
1036 dict<std::string, std::string> scratchpad;
1037
1038 int refcount_modules_;
1039 dict<RTLIL::IdString, RTLIL::Module*> modules_;
1040 std::vector<RTLIL::Binding*> bindings_;
1041
1042 std::vector<AST::AstNode*> verilog_packages, verilog_globals;
1043 std::unique_ptr<define_map_t> verilog_defines;
1044
1045 std::vector<RTLIL::Selection> selection_stack;
1046 dict<RTLIL::IdString, RTLIL::Selection> selection_vars;
1047 std::string selected_active_module;
1048
1049 Design();
1050 ~Design();
1051
1052 RTLIL::ObjRange<RTLIL::Module*> modules();
1053 RTLIL::Module *module(RTLIL::IdString name);
1054 const RTLIL::Module *module(RTLIL::IdString name) const;
1055 RTLIL::Module *top_module();
1056
hasDesign1057 bool has(RTLIL::IdString id) const {
1058 return modules_.count(id) != 0;
1059 }
1060
1061 void add(RTLIL::Module *module);
1062 void add(RTLIL::Binding *binding);
1063
1064 RTLIL::Module *addModule(RTLIL::IdString name);
1065 void remove(RTLIL::Module *module);
1066 void rename(RTLIL::Module *module, RTLIL::IdString new_name);
1067
1068 void scratchpad_unset(const std::string &varname);
1069
1070 void scratchpad_set_int(const std::string &varname, int value);
1071 void scratchpad_set_bool(const std::string &varname, bool value);
1072 void scratchpad_set_string(const std::string &varname, std::string value);
1073
1074 int scratchpad_get_int(const std::string &varname, int default_value = 0) const;
1075 bool scratchpad_get_bool(const std::string &varname, bool default_value = false) const;
1076 std::string scratchpad_get_string(const std::string &varname, const std::string &default_value = std::string()) const;
1077
1078 void sort();
1079 void check();
1080 void optimize();
1081
1082 bool selected_module(RTLIL::IdString mod_name) const;
1083 bool selected_whole_module(RTLIL::IdString mod_name) const;
1084 bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
1085
1086 bool selected_module(RTLIL::Module *mod) const;
1087 bool selected_whole_module(RTLIL::Module *mod) const;
1088
selectionDesign1089 RTLIL::Selection &selection() {
1090 return selection_stack.back();
1091 }
1092
selectionDesign1093 const RTLIL::Selection &selection() const {
1094 return selection_stack.back();
1095 }
1096
full_selectionDesign1097 bool full_selection() const {
1098 return selection_stack.back().full_selection;
1099 }
1100
selectedDesign1101 template<typename T1> bool selected(T1 *module) const {
1102 return selected_module(module->name);
1103 }
1104
selectedDesign1105 template<typename T1, typename T2> bool selected(T1 *module, T2 *member) const {
1106 return selected_member(module->name, member->name);
1107 }
1108
selectDesign1109 template<typename T1> void select(T1 *module) {
1110 if (selection_stack.size() > 0) {
1111 RTLIL::Selection &sel = selection_stack.back();
1112 sel.select(module);
1113 }
1114 }
1115
selectDesign1116 template<typename T1, typename T2> void select(T1 *module, T2 *member) {
1117 if (selection_stack.size() > 0) {
1118 RTLIL::Selection &sel = selection_stack.back();
1119 sel.select(module, member);
1120 }
1121 }
1122
1123
1124 std::vector<RTLIL::Module*> selected_modules() const;
1125 std::vector<RTLIL::Module*> selected_whole_modules() const;
1126 std::vector<RTLIL::Module*> selected_whole_modules_warn(bool include_wb = false) const;
1127 #ifdef WITH_PYTHON
1128 static std::map<unsigned int, RTLIL::Design*> *get_all_designs(void);
1129 #endif
1130 };
1131
1132 struct RTLIL::Module : public RTLIL::AttrObject
1133 {
1134 unsigned int hashidx_;
hashModule1135 unsigned int hash() const { return hashidx_; }
1136
1137 protected:
1138 void add(RTLIL::Wire *wire);
1139 void add(RTLIL::Cell *cell);
1140 void add(RTLIL::Process *process);
1141
1142 public:
1143 RTLIL::Design *design;
1144 pool<RTLIL::Monitor*> monitors;
1145
1146 int refcount_wires_;
1147 int refcount_cells_;
1148
1149 dict<RTLIL::IdString, RTLIL::Wire*> wires_;
1150 dict<RTLIL::IdString, RTLIL::Cell*> cells_;
1151
1152 std::vector<RTLIL::SigSig> connections_;
1153 std::vector<RTLIL::Binding*> bindings_;
1154
1155 RTLIL::IdString name;
1156 idict<RTLIL::IdString> avail_parameters;
1157 dict<RTLIL::IdString, RTLIL::Const> parameter_default_values;
1158 dict<RTLIL::IdString, RTLIL::Memory*> memories;
1159 dict<RTLIL::IdString, RTLIL::Process*> processes;
1160
1161 Module();
1162 virtual ~Module();
1163 virtual RTLIL::IdString derive(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Const> ¶meters, bool mayfail = false);
1164 virtual RTLIL::IdString derive(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Const> ¶meters, const dict<RTLIL::IdString, RTLIL::Module*> &interfaces, const dict<RTLIL::IdString, RTLIL::IdString> &modports, bool mayfail = false);
1165 virtual size_t count_id(RTLIL::IdString id);
1166 virtual void expand_interfaces(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Module *> &local_interfaces);
1167 virtual bool reprocess_if_necessary(RTLIL::Design *design);
1168
1169 virtual void sort();
1170 virtual void check();
1171 virtual void optimize();
1172 virtual void makeblackbox();
1173
1174 void connect(const RTLIL::SigSig &conn);
1175 void connect(const RTLIL::SigSpec &lhs, const RTLIL::SigSpec &rhs);
1176 void new_connections(const std::vector<RTLIL::SigSig> &new_conn);
1177 const std::vector<RTLIL::SigSig> &connections() const;
1178
1179 std::vector<RTLIL::IdString> ports;
1180 void fixup_ports();
1181
1182 template<typename T> void rewrite_sigspecs(T &functor);
1183 template<typename T> void rewrite_sigspecs2(T &functor);
1184 void cloneInto(RTLIL::Module *new_mod) const;
1185 virtual RTLIL::Module *clone() const;
1186
1187 bool has_memories() const;
1188 bool has_processes() const;
1189
1190 bool has_memories_warn() const;
1191 bool has_processes_warn() const;
1192
1193 std::vector<RTLIL::Wire*> selected_wires() const;
1194 std::vector<RTLIL::Cell*> selected_cells() const;
1195
selectedModule1196 template<typename T> bool selected(T *member) const {
1197 return design->selected_member(name, member->name);
1198 }
1199
wireModule1200 RTLIL::Wire* wire(RTLIL::IdString id) {
1201 auto it = wires_.find(id);
1202 return it == wires_.end() ? nullptr : it->second;
1203 }
cellModule1204 RTLIL::Cell* cell(RTLIL::IdString id) {
1205 auto it = cells_.find(id);
1206 return it == cells_.end() ? nullptr : it->second;
1207 }
1208
wireModule1209 const RTLIL::Wire* wire(RTLIL::IdString id) const{
1210 auto it = wires_.find(id);
1211 return it == wires_.end() ? nullptr : it->second;
1212 }
cellModule1213 const RTLIL::Cell* cell(RTLIL::IdString id) const {
1214 auto it = cells_.find(id);
1215 return it == cells_.end() ? nullptr : it->second;
1216 }
1217
wiresModule1218 RTLIL::ObjRange<RTLIL::Wire*> wires() { return RTLIL::ObjRange<RTLIL::Wire*>(&wires_, &refcount_wires_); }
cellsModule1219 RTLIL::ObjRange<RTLIL::Cell*> cells() { return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); }
1220
1221 void add(RTLIL::Binding *binding);
1222
1223 // Removing wires is expensive. If you have to remove wires, remove them all at once.
1224 void remove(const pool<RTLIL::Wire*> &wires);
1225 void remove(RTLIL::Cell *cell);
1226 void remove(RTLIL::Process *process);
1227
1228 void rename(RTLIL::Wire *wire, RTLIL::IdString new_name);
1229 void rename(RTLIL::Cell *cell, RTLIL::IdString new_name);
1230 void rename(RTLIL::IdString old_name, RTLIL::IdString new_name);
1231
1232 void swap_names(RTLIL::Wire *w1, RTLIL::Wire *w2);
1233 void swap_names(RTLIL::Cell *c1, RTLIL::Cell *c2);
1234
1235 RTLIL::IdString uniquify(RTLIL::IdString name);
1236 RTLIL::IdString uniquify(RTLIL::IdString name, int &index);
1237
1238 RTLIL::Wire *addWire(RTLIL::IdString name, int width = 1);
1239 RTLIL::Wire *addWire(RTLIL::IdString name, const RTLIL::Wire *other);
1240
1241 RTLIL::Cell *addCell(RTLIL::IdString name, RTLIL::IdString type);
1242 RTLIL::Cell *addCell(RTLIL::IdString name, const RTLIL::Cell *other);
1243
1244 RTLIL::Memory *addMemory(RTLIL::IdString name, const RTLIL::Memory *other);
1245
1246 RTLIL::Process *addProcess(RTLIL::IdString name);
1247 RTLIL::Process *addProcess(RTLIL::IdString name, const RTLIL::Process *other);
1248
1249 // The add* methods create a cell and return the created cell. All signals must exist in advance.
1250
1251 RTLIL::Cell* addNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1252 RTLIL::Cell* addPos (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1253 RTLIL::Cell* addNeg (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1254
1255 RTLIL::Cell* addAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1256 RTLIL::Cell* addOr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1257 RTLIL::Cell* addXor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1258 RTLIL::Cell* addXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1259
1260 RTLIL::Cell* addReduceAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1261 RTLIL::Cell* addReduceOr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1262 RTLIL::Cell* addReduceXor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1263 RTLIL::Cell* addReduceXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1264 RTLIL::Cell* addReduceBool (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1265
1266 RTLIL::Cell* addShl (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1267 RTLIL::Cell* addShr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1268 RTLIL::Cell* addSshl (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1269 RTLIL::Cell* addSshr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1270 RTLIL::Cell* addShift (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1271 RTLIL::Cell* addShiftx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1272
1273 RTLIL::Cell* addLt (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1274 RTLIL::Cell* addLe (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1275 RTLIL::Cell* addEq (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1276 RTLIL::Cell* addNe (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1277 RTLIL::Cell* addEqx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1278 RTLIL::Cell* addNex (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1279 RTLIL::Cell* addGe (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1280 RTLIL::Cell* addGt (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1281
1282 RTLIL::Cell* addAdd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1283 RTLIL::Cell* addSub (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1284 RTLIL::Cell* addMul (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1285 // truncating division
1286 RTLIL::Cell* addDiv (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1287 // truncating modulo
1288 RTLIL::Cell* addMod (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1289 RTLIL::Cell* addDivFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1290 RTLIL::Cell* addModFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1291 RTLIL::Cell* addPow (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool a_signed = false, bool b_signed = false, const std::string &src = "");
1292
1293 RTLIL::Cell* addLogicNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1294 RTLIL::Cell* addLogicAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1295 RTLIL::Cell* addLogicOr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1296
1297 RTLIL::Cell* addMux (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1298 RTLIL::Cell* addPmux (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1299
1300 RTLIL::Cell* addSlice (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, RTLIL::Const offset, const std::string &src = "");
1301 RTLIL::Cell* addConcat (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1302 RTLIL::Cell* addLut (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, RTLIL::Const lut, const std::string &src = "");
1303 RTLIL::Cell* addTribuf (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1304 RTLIL::Cell* addAssert (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1305 RTLIL::Cell* addAssume (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1306 RTLIL::Cell* addLive (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1307 RTLIL::Cell* addFair (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1308 RTLIL::Cell* addCover (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1309 RTLIL::Cell* addEquiv (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1310
1311 RTLIL::Cell* addSr (RTLIL::IdString name, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, const RTLIL::SigSpec &sig_q, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1312 RTLIL::Cell* addFf (RTLIL::IdString name, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const std::string &src = "");
1313 RTLIL::Cell* addDff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, const std::string &src = "");
1314 RTLIL::Cell* addDffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, const std::string &src = "");
1315 RTLIL::Cell* addDffsr (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1316 RTLIL::Cell* addDffsre (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1317 RTLIL::Cell* addAdff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool clk_polarity = true, bool arst_polarity = true, const std::string &src = "");
1318 RTLIL::Cell* addAdffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool clk_polarity = true, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1319 RTLIL::Cell* addAldff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool aload_polarity = true, const std::string &src = "");
1320 RTLIL::Cell* addAldffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool en_polarity = true, bool aload_polarity = true, const std::string &src = "");
1321 RTLIL::Cell* addSdff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool srst_polarity = true, const std::string &src = "");
1322 RTLIL::Cell* addSdffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1323 RTLIL::Cell* addSdffce (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1324 RTLIL::Cell* addDlatch (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, const std::string &src = "");
1325 RTLIL::Cell* addAdlatch (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1326 RTLIL::Cell* addDlatchsr (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1327
1328 RTLIL::Cell* addBufGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_y, const std::string &src = "");
1329 RTLIL::Cell* addNotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_y, const std::string &src = "");
1330 RTLIL::Cell* addAndGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1331 RTLIL::Cell* addNandGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1332 RTLIL::Cell* addOrGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1333 RTLIL::Cell* addNorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1334 RTLIL::Cell* addXorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1335 RTLIL::Cell* addXnorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1336 RTLIL::Cell* addAndnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1337 RTLIL::Cell* addOrnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1338 RTLIL::Cell* addMuxGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const RTLIL::SigBit &sig_y, const std::string &src = "");
1339 RTLIL::Cell* addNmuxGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const RTLIL::SigBit &sig_y, const std::string &src = "");
1340 RTLIL::Cell* addAoi3Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_y, const std::string &src = "");
1341 RTLIL::Cell* addOai3Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_y, const std::string &src = "");
1342 RTLIL::Cell* addAoi4Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const RTLIL::SigBit &sig_y, const std::string &src = "");
1343 RTLIL::Cell* addOai4Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const RTLIL::SigBit &sig_y, const std::string &src = "");
1344
1345 RTLIL::Cell* addSrGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1346 const RTLIL::SigSpec &sig_q, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1347 RTLIL::Cell* addFfGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const std::string &src = "");
1348 RTLIL::Cell* addDffGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, const std::string &src = "");
1349 RTLIL::Cell* addDffeGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, const std::string &src = "");
1350 RTLIL::Cell* addDffsrGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1351 RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1352 RTLIL::Cell* addDffsreGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1353 RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1354 RTLIL::Cell* addAdffGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1355 bool arst_value = false, bool clk_polarity = true, bool arst_polarity = true, const std::string &src = "");
1356 RTLIL::Cell* addAdffeGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1357 bool arst_value = false, bool clk_polarity = true, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1358 RTLIL::Cell* addAldffGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1359 const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool aload_polarity = true, const std::string &src = "");
1360 RTLIL::Cell* addAldffeGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1361 const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool en_polarity = true, bool aload_polarity = true, const std::string &src = "");
1362 RTLIL::Cell* addSdffGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1363 bool srst_value = false, bool clk_polarity = true, bool srst_polarity = true, const std::string &src = "");
1364 RTLIL::Cell* addSdffeGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1365 bool srst_value = false, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1366 RTLIL::Cell* addSdffceGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1367 bool srst_value = false, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1368 RTLIL::Cell* addDlatchGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, const std::string &src = "");
1369 RTLIL::Cell* addAdlatchGate(RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1370 bool arst_value = false, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1371 RTLIL::Cell* addDlatchsrGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1372 RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1373
1374 // The methods without the add* prefix create a cell and an output signal. They return the newly created output signal.
1375
1376 RTLIL::SigSpec Not (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1377 RTLIL::SigSpec Pos (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1378 RTLIL::SigSpec Neg (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1379
1380 RTLIL::SigSpec And (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1381 RTLIL::SigSpec Or (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1382 RTLIL::SigSpec Xor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1383 RTLIL::SigSpec Xnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1384
1385 RTLIL::SigSpec ReduceAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1386 RTLIL::SigSpec ReduceOr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1387 RTLIL::SigSpec ReduceXor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1388 RTLIL::SigSpec ReduceXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1389 RTLIL::SigSpec ReduceBool (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1390
1391 RTLIL::SigSpec Shl (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1392 RTLIL::SigSpec Shr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1393 RTLIL::SigSpec Sshl (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1394 RTLIL::SigSpec Sshr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1395 RTLIL::SigSpec Shift (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1396 RTLIL::SigSpec Shiftx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1397
1398 RTLIL::SigSpec Lt (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1399 RTLIL::SigSpec Le (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1400 RTLIL::SigSpec Eq (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1401 RTLIL::SigSpec Ne (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1402 RTLIL::SigSpec Eqx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1403 RTLIL::SigSpec Nex (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1404 RTLIL::SigSpec Ge (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1405 RTLIL::SigSpec Gt (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1406
1407 RTLIL::SigSpec Add (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1408 RTLIL::SigSpec Sub (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1409 RTLIL::SigSpec Mul (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1410 // truncating division
1411 RTLIL::SigSpec Div (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1412 // truncating modulo
1413 RTLIL::SigSpec Mod (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1414 RTLIL::SigSpec DivFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1415 RTLIL::SigSpec ModFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1416 RTLIL::SigSpec Pow (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool a_signed = false, bool b_signed = false, const std::string &src = "");
1417
1418 RTLIL::SigSpec LogicNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1419 RTLIL::SigSpec LogicAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1420 RTLIL::SigSpec LogicOr (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1421
1422 RTLIL::SigSpec Mux (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const std::string &src = "");
1423 RTLIL::SigSpec Pmux (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const std::string &src = "");
1424
1425 RTLIL::SigBit BufGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const std::string &src = "");
1426 RTLIL::SigBit NotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const std::string &src = "");
1427 RTLIL::SigBit AndGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1428 RTLIL::SigBit NandGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1429 RTLIL::SigBit OrGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1430 RTLIL::SigBit NorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1431 RTLIL::SigBit XorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1432 RTLIL::SigBit XnorGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1433 RTLIL::SigBit AndnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1434 RTLIL::SigBit OrnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1435 RTLIL::SigBit MuxGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const std::string &src = "");
1436 RTLIL::SigBit NmuxGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const std::string &src = "");
1437 RTLIL::SigBit Aoi3Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const std::string &src = "");
1438 RTLIL::SigBit Oai3Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const std::string &src = "");
1439 RTLIL::SigBit Aoi4Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const std::string &src = "");
1440 RTLIL::SigBit Oai4Gate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const std::string &src = "");
1441
1442 RTLIL::SigSpec Anyconst (RTLIL::IdString name, int width = 1, const std::string &src = "");
1443 RTLIL::SigSpec Anyseq (RTLIL::IdString name, int width = 1, const std::string &src = "");
1444 RTLIL::SigSpec Allconst (RTLIL::IdString name, int width = 1, const std::string &src = "");
1445 RTLIL::SigSpec Allseq (RTLIL::IdString name, int width = 1, const std::string &src = "");
1446 RTLIL::SigSpec Initstate (RTLIL::IdString name, const std::string &src = "");
1447
1448 #ifdef WITH_PYTHON
1449 static std::map<unsigned int, RTLIL::Module*> *get_all_modules(void);
1450 #endif
1451 };
1452
1453 struct RTLIL::Wire : public RTLIL::AttrObject
1454 {
1455 unsigned int hashidx_;
hashWire1456 unsigned int hash() const { return hashidx_; }
1457
1458 protected:
1459 // use module->addWire() and module->remove() to create or destroy wires
1460 friend struct RTLIL::Module;
1461 Wire();
1462 ~Wire();
1463
1464 public:
1465 // do not simply copy wires
1466 Wire(RTLIL::Wire &other) = delete;
1467 void operator=(RTLIL::Wire &other) = delete;
1468
1469 RTLIL::Module *module;
1470 RTLIL::IdString name;
1471 int width, start_offset, port_id;
1472 bool port_input, port_output, upto, is_signed;
1473
1474 #ifdef WITH_PYTHON
1475 static std::map<unsigned int, RTLIL::Wire*> *get_all_wires(void);
1476 #endif
1477 };
1478
1479 struct RTLIL::Memory : public RTLIL::AttrObject
1480 {
1481 unsigned int hashidx_;
hashMemory1482 unsigned int hash() const { return hashidx_; }
1483
1484 Memory();
1485
1486 RTLIL::IdString name;
1487 int width, start_offset, size;
1488 #ifdef WITH_PYTHON
1489 ~Memory();
1490 static std::map<unsigned int, RTLIL::Memory*> *get_all_memorys(void);
1491 #endif
1492 };
1493
1494 struct RTLIL::Cell : public RTLIL::AttrObject
1495 {
1496 unsigned int hashidx_;
hashCell1497 unsigned int hash() const { return hashidx_; }
1498
1499 protected:
1500 // use module->addCell() and module->remove() to create or destroy cells
1501 friend struct RTLIL::Module;
1502 Cell();
1503 ~Cell();
1504
1505 public:
1506 // do not simply copy cells
1507 Cell(RTLIL::Cell &other) = delete;
1508 void operator=(RTLIL::Cell &other) = delete;
1509
1510 RTLIL::Module *module;
1511 RTLIL::IdString name;
1512 RTLIL::IdString type;
1513 dict<RTLIL::IdString, RTLIL::SigSpec> connections_;
1514 dict<RTLIL::IdString, RTLIL::Const> parameters;
1515
1516 // access cell ports
1517 bool hasPort(RTLIL::IdString portname) const;
1518 void unsetPort(RTLIL::IdString portname);
1519 void setPort(RTLIL::IdString portname, RTLIL::SigSpec signal);
1520 const RTLIL::SigSpec &getPort(RTLIL::IdString portname) const;
1521 const dict<RTLIL::IdString, RTLIL::SigSpec> &connections() const;
1522
1523 // information about cell ports
1524 bool known() const;
1525 bool input(RTLIL::IdString portname) const;
1526 bool output(RTLIL::IdString portname) const;
1527
1528 // access cell parameters
1529 bool hasParam(RTLIL::IdString paramname) const;
1530 void unsetParam(RTLIL::IdString paramname);
1531 void setParam(RTLIL::IdString paramname, RTLIL::Const value);
1532 const RTLIL::Const &getParam(RTLIL::IdString paramname) const;
1533
1534 void sort();
1535 void check();
1536 void fixup_parameters(bool set_a_signed = false, bool set_b_signed = false);
1537
has_keep_attrCell1538 bool has_keep_attr() const {
1539 return get_bool_attribute(ID::keep) || (module && module->design && module->design->module(type) &&
1540 module->design->module(type)->get_bool_attribute(ID::keep));
1541 }
1542
1543 template<typename T> void rewrite_sigspecs(T &functor);
1544 template<typename T> void rewrite_sigspecs2(T &functor);
1545
1546 #ifdef WITH_PYTHON
1547 static std::map<unsigned int, RTLIL::Cell*> *get_all_cells(void);
1548 #endif
1549
1550 bool has_memid() const;
1551 bool is_mem_cell() const;
1552 };
1553
1554 struct RTLIL::CaseRule : public RTLIL::AttrObject
1555 {
1556 std::vector<RTLIL::SigSpec> compare;
1557 std::vector<RTLIL::SigSig> actions;
1558 std::vector<RTLIL::SwitchRule*> switches;
1559
1560 ~CaseRule();
1561
1562 bool empty() const;
1563
1564 template<typename T> void rewrite_sigspecs(T &functor);
1565 template<typename T> void rewrite_sigspecs2(T &functor);
1566 RTLIL::CaseRule *clone() const;
1567 };
1568
1569 struct RTLIL::SwitchRule : public RTLIL::AttrObject
1570 {
1571 RTLIL::SigSpec signal;
1572 std::vector<RTLIL::CaseRule*> cases;
1573
1574 ~SwitchRule();
1575
1576 bool empty() const;
1577
1578 template<typename T> void rewrite_sigspecs(T &functor);
1579 template<typename T> void rewrite_sigspecs2(T &functor);
1580 RTLIL::SwitchRule *clone() const;
1581 };
1582
1583 struct RTLIL::MemWriteAction : RTLIL::AttrObject
1584 {
1585 RTLIL::IdString memid;
1586 RTLIL::SigSpec address;
1587 RTLIL::SigSpec data;
1588 RTLIL::SigSpec enable;
1589 RTLIL::Const priority_mask;
1590 };
1591
1592 struct RTLIL::SyncRule
1593 {
1594 RTLIL::SyncType type;
1595 RTLIL::SigSpec signal;
1596 std::vector<RTLIL::SigSig> actions;
1597 std::vector<RTLIL::MemWriteAction> mem_write_actions;
1598
1599 template<typename T> void rewrite_sigspecs(T &functor);
1600 template<typename T> void rewrite_sigspecs2(T &functor);
1601 RTLIL::SyncRule *clone() const;
1602 };
1603
1604 struct RTLIL::Process : public RTLIL::AttrObject
1605 {
1606 unsigned int hashidx_;
hashProcess1607 unsigned int hash() const { return hashidx_; }
1608
1609 protected:
1610 // use module->addProcess() and module->remove() to create or destroy processes
1611 friend struct RTLIL::Module;
1612 Process();
1613 ~Process();
1614
1615 public:
1616 RTLIL::IdString name;
1617 RTLIL::Module *module;
1618 RTLIL::CaseRule root_case;
1619 std::vector<RTLIL::SyncRule*> syncs;
1620
1621 template<typename T> void rewrite_sigspecs(T &functor);
1622 template<typename T> void rewrite_sigspecs2(T &functor);
1623 RTLIL::Process *clone() const;
1624 };
1625
1626
SigBit()1627 inline RTLIL::SigBit::SigBit() : wire(NULL), data(RTLIL::State::S0) { }
SigBit(RTLIL::State bit)1628 inline RTLIL::SigBit::SigBit(RTLIL::State bit) : wire(NULL), data(bit) { }
SigBit(bool bit)1629 inline RTLIL::SigBit::SigBit(bool bit) : wire(NULL), data(bit ? State::S1 : State::S0) { }
SigBit(RTLIL::Wire * wire)1630 inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire) : wire(wire), offset(0) { log_assert(wire && wire->width == 1); }
SigBit(RTLIL::Wire * wire,int offset)1631 inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire, int offset) : wire(wire), offset(offset) { log_assert(wire != nullptr); }
SigBit(const RTLIL::SigChunk & chunk)1632 inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk) : wire(chunk.wire) { log_assert(chunk.width == 1); if (wire) offset = chunk.offset; else data = chunk.data[0]; }
SigBit(const RTLIL::SigChunk & chunk,int index)1633 inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk, int index) : wire(chunk.wire) { if (wire) offset = chunk.offset + index; else data = chunk.data[index]; }
1634
1635 inline bool RTLIL::SigBit::operator<(const RTLIL::SigBit &other) const {
1636 if (wire == other.wire)
1637 return wire ? (offset < other.offset) : (data < other.data);
1638 if (wire != nullptr && other.wire != nullptr)
1639 return wire->name < other.wire->name;
1640 return (wire != nullptr) < (other.wire != nullptr);
1641 }
1642
1643 inline bool RTLIL::SigBit::operator==(const RTLIL::SigBit &other) const {
1644 return (wire == other.wire) && (wire ? (offset == other.offset) : (data == other.data));
1645 }
1646
1647 inline bool RTLIL::SigBit::operator!=(const RTLIL::SigBit &other) const {
1648 return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
1649 }
1650
hash()1651 inline unsigned int RTLIL::SigBit::hash() const {
1652 if (wire)
1653 return mkhash_add(wire->name.hash(), offset);
1654 return data;
1655 }
1656
1657 inline RTLIL::SigBit &RTLIL::SigSpecIterator::operator*() const {
1658 return (*sig_p)[index];
1659 }
1660
1661 inline const RTLIL::SigBit &RTLIL::SigSpecConstIterator::operator*() const {
1662 return (*sig_p)[index];
1663 }
1664
SigBit(const RTLIL::SigSpec & sig)1665 inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec &sig) {
1666 log_assert(sig.size() == 1 && sig.chunks().size() == 1);
1667 *this = SigBit(sig.chunks().front());
1668 }
1669
1670 template<typename T>
rewrite_sigspecs(T & functor)1671 void RTLIL::Module::rewrite_sigspecs(T &functor)
1672 {
1673 for (auto &it : cells_)
1674 it.second->rewrite_sigspecs(functor);
1675 for (auto &it : processes)
1676 it.second->rewrite_sigspecs(functor);
1677 for (auto &it : connections_) {
1678 functor(it.first);
1679 functor(it.second);
1680 }
1681 }
1682
1683 template<typename T>
rewrite_sigspecs2(T & functor)1684 void RTLIL::Module::rewrite_sigspecs2(T &functor)
1685 {
1686 for (auto &it : cells_)
1687 it.second->rewrite_sigspecs2(functor);
1688 for (auto &it : processes)
1689 it.second->rewrite_sigspecs2(functor);
1690 for (auto &it : connections_) {
1691 functor(it.first, it.second);
1692 }
1693 }
1694
1695 template<typename T>
rewrite_sigspecs(T & functor)1696 void RTLIL::Cell::rewrite_sigspecs(T &functor) {
1697 for (auto &it : connections_)
1698 functor(it.second);
1699 }
1700
1701 template<typename T>
rewrite_sigspecs2(T & functor)1702 void RTLIL::Cell::rewrite_sigspecs2(T &functor) {
1703 for (auto &it : connections_)
1704 functor(it.second);
1705 }
1706
1707 template<typename T>
rewrite_sigspecs(T & functor)1708 void RTLIL::CaseRule::rewrite_sigspecs(T &functor) {
1709 for (auto &it : compare)
1710 functor(it);
1711 for (auto &it : actions) {
1712 functor(it.first);
1713 functor(it.second);
1714 }
1715 for (auto it : switches)
1716 it->rewrite_sigspecs(functor);
1717 }
1718
1719 template<typename T>
rewrite_sigspecs2(T & functor)1720 void RTLIL::CaseRule::rewrite_sigspecs2(T &functor) {
1721 for (auto &it : compare)
1722 functor(it);
1723 for (auto &it : actions) {
1724 functor(it.first, it.second);
1725 }
1726 for (auto it : switches)
1727 it->rewrite_sigspecs2(functor);
1728 }
1729
1730 template<typename T>
rewrite_sigspecs(T & functor)1731 void RTLIL::SwitchRule::rewrite_sigspecs(T &functor)
1732 {
1733 functor(signal);
1734 for (auto it : cases)
1735 it->rewrite_sigspecs(functor);
1736 }
1737
1738 template<typename T>
rewrite_sigspecs2(T & functor)1739 void RTLIL::SwitchRule::rewrite_sigspecs2(T &functor)
1740 {
1741 functor(signal);
1742 for (auto it : cases)
1743 it->rewrite_sigspecs2(functor);
1744 }
1745
1746 template<typename T>
rewrite_sigspecs(T & functor)1747 void RTLIL::SyncRule::rewrite_sigspecs(T &functor)
1748 {
1749 functor(signal);
1750 for (auto &it : actions) {
1751 functor(it.first);
1752 functor(it.second);
1753 }
1754 for (auto &it : mem_write_actions) {
1755 functor(it.address);
1756 functor(it.data);
1757 functor(it.enable);
1758 }
1759 }
1760
1761 template<typename T>
rewrite_sigspecs2(T & functor)1762 void RTLIL::SyncRule::rewrite_sigspecs2(T &functor)
1763 {
1764 functor(signal);
1765 for (auto &it : actions) {
1766 functor(it.first, it.second);
1767 }
1768 for (auto &it : mem_write_actions) {
1769 functor(it.address);
1770 functor(it.data);
1771 functor(it.enable);
1772 }
1773 }
1774
1775 template<typename T>
rewrite_sigspecs(T & functor)1776 void RTLIL::Process::rewrite_sigspecs(T &functor)
1777 {
1778 root_case.rewrite_sigspecs(functor);
1779 for (auto it : syncs)
1780 it->rewrite_sigspecs(functor);
1781 }
1782
1783 template<typename T>
rewrite_sigspecs2(T & functor)1784 void RTLIL::Process::rewrite_sigspecs2(T &functor)
1785 {
1786 root_case.rewrite_sigspecs2(functor);
1787 for (auto it : syncs)
1788 it->rewrite_sigspecs2(functor);
1789 }
1790
1791 YOSYS_NAMESPACE_END
1792
1793 #endif
1794