2 * yosys -- Yosys Open SYnthesis Suite
4 * Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>
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.
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.
20 #include "kernel/yosys.h"
29 enum State
: unsigned char {
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)
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
49 enum ConstFlags
: unsigned char {
51 CONST_FLAG_STRING
= 1,
52 CONST_FLAG_SIGNED
= 2, // only used for parameters
53 CONST_FLAG_REAL
= 4 // only used for parameters
67 struct SigSpecIterator
;
68 struct SigSpecConstIterator
;
75 typedef std::pair
<SigSpec
, SigSpec
> SigSig
;
79 #undef YOSYS_XTRACE_GET_PUT
80 #undef YOSYS_SORT_ID_FREE_LIST
81 #undef YOSYS_USE_STICKY_IDS
82 #undef YOSYS_NO_IDS_REFCNT
84 // the global id string cache
86 static struct destruct_guard_t
{
87 bool ok
; // POD, will be initialized to zero
88 destruct_guard_t() { ok
= true; }
89 ~destruct_guard_t() { ok
= false; }
92 static std::vector
<char*> global_id_storage_
;
93 static dict
<char*, int, hash_cstr_ops
> global_id_index_
;
94 #ifndef YOSYS_NO_IDS_REFCNT
95 static std::vector
<int> global_refcount_storage_
;
96 static std::vector
<int> global_free_idx_list_
;
99 #ifdef YOSYS_USE_STICKY_IDS
100 static int last_created_idx_ptr_
;
101 static int last_created_idx_
[8];
104 static inline void xtrace_db_dump()
106 #ifdef YOSYS_XTRACE_GET_PUT
107 for (int idx
= 0; idx
< GetSize(global_id_storage_
); idx
++)
109 if (global_id_storage_
.at(idx
) == nullptr)
110 log("#X# DB-DUMP index %d: FREE\n", idx
);
112 log("#X# DB-DUMP index %d: '%s' (ref %d)\n", idx
, global_id_storage_
.at(idx
), global_refcount_storage_
.at(idx
));
117 static inline void checkpoint()
119 #ifdef YOSYS_USE_STICKY_IDS
120 last_created_idx_ptr_
= 0;
121 for (int i
= 0; i
< 8; i
++) {
122 if (last_created_idx_
[i
])
123 put_reference(last_created_idx_
[i
]);
124 last_created_idx_
[i
] = 0;
127 #ifdef YOSYS_SORT_ID_FREE_LIST
128 std::sort(global_free_idx_list_
.begin(), global_free_idx_list_
.end(), std::greater
<int>());
132 static inline int get_reference(int idx
)
135 #ifndef YOSYS_NO_IDS_REFCNT
136 global_refcount_storage_
[idx
]++;
138 #ifdef YOSYS_XTRACE_GET_PUT
140 log("#X# GET-BY-INDEX '%s' (index %d, refcount %d)\n", global_id_storage_
.at(idx
), idx
, global_refcount_storage_
.at(idx
));
146 static int get_reference(const char *p
)
148 log_assert(destruct_guard
.ok
);
153 log_assert(p
[0] == '$' || p
[0] == '\\');
154 log_assert(p
[1] != 0);
156 auto it
= global_id_index_
.find((char*)p
);
157 if (it
!= global_id_index_
.end()) {
158 #ifndef YOSYS_NO_IDS_REFCNT
159 global_refcount_storage_
.at(it
->second
)++;
161 #ifdef YOSYS_XTRACE_GET_PUT
163 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
));
168 #ifndef YOSYS_NO_IDS_REFCNT
169 if (global_free_idx_list_
.empty()) {
170 if (global_id_storage_
.empty()) {
171 global_refcount_storage_
.push_back(0);
172 global_id_storage_
.push_back((char*)"");
173 global_id_index_
[global_id_storage_
.back()] = 0;
175 log_assert(global_id_storage_
.size() < 0x40000000);
176 global_free_idx_list_
.push_back(global_id_storage_
.size());
177 global_id_storage_
.push_back(nullptr);
178 global_refcount_storage_
.push_back(0);
181 int idx
= global_free_idx_list_
.back();
182 global_free_idx_list_
.pop_back();
183 global_id_storage_
.at(idx
) = strdup(p
);
184 global_id_index_
[global_id_storage_
.at(idx
)] = idx
;
185 global_refcount_storage_
.at(idx
)++;
187 if (global_id_storage_
.empty()) {
188 global_id_storage_
.push_back((char*)"");
189 global_id_index_
[global_id_storage_
.back()] = 0;
191 int idx
= global_id_storage_
.size();
192 global_id_storage_
.push_back(strdup(p
));
193 global_id_index_
[global_id_storage_
.back()] = idx
;
197 log("#X# New IdString '%s' with index %d.\n", p
, idx
);
198 log_backtrace("-X- ", yosys_xtrace
-1);
201 #ifdef YOSYS_XTRACE_GET_PUT
203 log("#X# GET-BY-NAME '%s' (index %d, refcount %d)\n", global_id_storage_
.at(idx
), idx
, global_refcount_storage_
.at(idx
));
206 #ifdef YOSYS_USE_STICKY_IDS
207 // Avoid Create->Delete->Create pattern
208 if (last_created_idx_
[last_created_idx_ptr_
])
209 put_reference(last_created_idx_
[last_created_idx_ptr_
]);
210 last_created_idx_
[last_created_idx_ptr_
] = idx
;
211 get_reference(last_created_idx_
[last_created_idx_ptr_
]);
212 last_created_idx_ptr_
= (last_created_idx_ptr_
+ 1) & 7;
218 #ifndef YOSYS_NO_IDS_REFCNT
219 static inline void put_reference(int idx
)
221 // put_reference() may be called from destructors after the destructor of
222 // global_refcount_storage_ has been run. in this case we simply do nothing.
223 if (!destruct_guard
.ok
|| !idx
)
226 #ifdef YOSYS_XTRACE_GET_PUT
228 log("#X# PUT '%s' (index %d, refcount %d)\n", global_id_storage_
.at(idx
), idx
, global_refcount_storage_
.at(idx
));
232 int &refcount
= global_refcount_storage_
[idx
];
237 log_assert(refcount
== 0);
240 log("#X# Removed IdString '%s' with index %d.\n", global_id_storage_
.at(idx
), idx
);
241 log_backtrace("-X- ", yosys_xtrace
-1);
244 global_id_index_
.erase(global_id_storage_
.at(idx
));
245 free(global_id_storage_
.at(idx
));
246 global_id_storage_
.at(idx
) = nullptr;
247 global_free_idx_list_
.push_back(idx
);
250 static inline void put_reference(int) { }
253 // the actual IdString object is just is a single int
257 inline IdString() : index_(0) { }
258 inline IdString(const char *str
) : index_(get_reference(str
)) { }
259 inline IdString(const IdString
&str
) : index_(get_reference(str
.index_
)) { }
260 inline IdString(IdString
&&str
) : index_(str
.index_
) { str
.index_
= 0; }
261 inline IdString(const std::string
&str
) : index_(get_reference(str
.c_str())) { }
262 inline ~IdString() { put_reference(index_
); }
264 inline void operator=(const IdString
&rhs
) {
265 put_reference(index_
);
266 index_
= get_reference(rhs
.index_
);
269 inline void operator=(const char *rhs
) {
274 inline void operator=(const std::string
&rhs
) {
279 inline const char *c_str() const {
280 return global_id_storage_
.at(index_
);
283 inline std::string
str() const {
284 return std::string(global_id_storage_
.at(index_
));
287 inline bool operator<(const IdString
&rhs
) const {
288 return index_
< rhs
.index_
;
291 inline bool operator==(const IdString
&rhs
) const { return index_
== rhs
.index_
; }
292 inline bool operator!=(const IdString
&rhs
) const { return index_
!= rhs
.index_
; }
294 // The methods below are just convenience functions for better compatibility with std::string.
296 bool operator==(const std::string
&rhs
) const { return str() == rhs
; }
297 bool operator!=(const std::string
&rhs
) const { return str() != rhs
; }
299 bool operator==(const char *rhs
) const { return strcmp(c_str(), rhs
) == 0; }
300 bool operator!=(const char *rhs
) const { return strcmp(c_str(), rhs
) != 0; }
302 char operator[](size_t i
) const {
303 const char *p
= c_str();
304 for (; i
!= 0; i
--, p
++)
309 std::string
substr(size_t pos
= 0, size_t len
= std::string::npos
) const {
310 if (len
== std::string::npos
|| len
>= strlen(c_str() + pos
))
311 return std::string(c_str() + pos
);
313 return std::string(c_str() + pos
, len
);
316 int compare(size_t pos
, size_t len
, const char* s
) const {
317 return strncmp(c_str()+pos
, s
, len
);
320 bool begins_with(const char* prefix
) const {
321 size_t len
= strlen(prefix
);
322 if (size() < len
) return false;
323 return compare(0, len
, prefix
) == 0;
326 bool ends_with(const char* suffix
) const {
327 size_t len
= strlen(suffix
);
328 if (size() < len
) return false;
329 return compare(size()-len
, len
, suffix
) == 0;
332 size_t size() const {
333 return strlen(c_str());
337 return c_str()[0] == 0;
344 unsigned int hash() const {
348 // The following is a helper key_compare class. Instead of for example std::set<Cell*>
349 // use std::set<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the
350 // set has an influence on the algorithm.
352 template<typename T
> struct compare_ptr_by_name
{
353 bool operator()(const T
*a
, const T
*b
) const {
354 return (a
== nullptr || b
== nullptr) ? (a
< b
) : (a
->name
< b
->name
);
358 // often one needs to check if a given IdString is part of a list (for example a list
359 // of cell types). the following functions helps with that.
361 template<typename T
, typename
... Args
>
362 bool in(T first
, Args
... rest
) const {
363 return in(first
) || in(rest
...);
366 bool in(IdString rhs
) const { return *this == rhs
; }
367 bool in(const char *rhs
) const { return *this == rhs
; }
368 bool in(const std::string
&rhs
) const { return *this == rhs
; }
369 bool in(const pool
<IdString
> &rhs
) const { return rhs
.count(*this) != 0; }
373 // defined in rtlil.cc, initialized in yosys.cc
374 extern IdString A
, B
, Y
;
375 extern IdString keep
;
376 extern IdString whitebox
;
377 extern IdString blackbox
;
380 extern dict
<std::string
, std::string
> constpad
;
382 static inline std::string
escape_id(std::string str
) {
383 if (str
.size() > 0 && str
[0] != '\\' && str
[0] != '$')
388 static inline std::string
unescape_id(std::string str
) {
393 if (str
[1] == '$' || str
[1] == '\\')
395 if (str
[1] >= '0' && str
[1] <= '9')
397 return str
.substr(1);
400 static inline std::string
unescape_id(RTLIL::IdString str
) {
401 return unescape_id(str
.str());
404 static inline const char *id2cstr(const RTLIL::IdString
&str
) {
408 template <typename T
> struct sort_by_name_id
{
409 bool operator()(T
*a
, T
*b
) const {
410 return a
->name
< b
->name
;
414 template <typename T
> struct sort_by_name_str
{
415 bool operator()(T
*a
, T
*b
) const {
416 return strcmp(a
->name
.c_str(), b
->name
.c_str()) < 0;
420 struct sort_by_id_str
{
421 bool operator()(RTLIL::IdString a
, RTLIL::IdString b
) const {
422 return strcmp(a
.c_str(), b
.c_str()) < 0;
426 // see calc.cc for the implementation of this functions
427 RTLIL::Const
const_not (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
428 RTLIL::Const
const_and (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
429 RTLIL::Const
const_or (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
430 RTLIL::Const
const_xor (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
431 RTLIL::Const
const_xnor (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
433 RTLIL::Const
const_reduce_and (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
434 RTLIL::Const
const_reduce_or (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
435 RTLIL::Const
const_reduce_xor (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
436 RTLIL::Const
const_reduce_xnor (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
437 RTLIL::Const
const_reduce_bool (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
439 RTLIL::Const
const_logic_not (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
440 RTLIL::Const
const_logic_and (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
441 RTLIL::Const
const_logic_or (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
443 RTLIL::Const
const_shl (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
444 RTLIL::Const
const_shr (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
445 RTLIL::Const
const_sshl (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
446 RTLIL::Const
const_sshr (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
447 RTLIL::Const
const_shift (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
448 RTLIL::Const
const_shiftx (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
450 RTLIL::Const
const_lt (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
451 RTLIL::Const
const_le (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
452 RTLIL::Const
const_eq (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
453 RTLIL::Const
const_ne (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
454 RTLIL::Const
const_eqx (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
455 RTLIL::Const
const_nex (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
456 RTLIL::Const
const_ge (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
457 RTLIL::Const
const_gt (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
459 RTLIL::Const
const_add (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
460 RTLIL::Const
const_sub (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
461 RTLIL::Const
const_mul (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
462 RTLIL::Const
const_div (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
463 RTLIL::Const
const_mod (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
464 RTLIL::Const
const_pow (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
466 RTLIL::Const
const_pos (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
467 RTLIL::Const
const_neg (const RTLIL::Const
&arg1
, const RTLIL::Const
&arg2
, bool signed1
, bool signed2
, int result_len
);
470 // This iterator-range-pair is used for Design::modules(), Module::wires() and Module::cells().
471 // It maintains a reference counter that is used to make sure that the container is not modified while being iterated over.
475 using iterator_category
= std::forward_iterator_tag
;
476 using value_type
= T
;
477 using difference_type
= ptrdiff_t;
479 using reference
= T
&;
480 typename dict
<RTLIL::IdString
, T
>::iterator it
;
481 dict
<RTLIL::IdString
, T
> *list_p
;
484 ObjIterator() : list_p(nullptr), refcount_p(nullptr) {
487 ObjIterator(decltype(list_p
) list_p
, int *refcount_p
) : list_p(list_p
), refcount_p(refcount_p
) {
488 if (list_p
->empty()) {
489 this->list_p
= nullptr;
490 this->refcount_p
= nullptr;
492 it
= list_p
->begin();
497 ObjIterator(const RTLIL::ObjIterator
<T
> &other
) {
499 list_p
= other
.list_p
;
500 refcount_p
= other
.refcount_p
;
505 ObjIterator
&operator=(const RTLIL::ObjIterator
<T
> &other
) {
509 list_p
= other
.list_p
;
510 refcount_p
= other
.refcount_p
;
521 inline T
operator*() const {
522 log_assert(list_p
!= nullptr);
526 inline bool operator!=(const RTLIL::ObjIterator
<T
> &other
) const {
527 if (list_p
== nullptr || other
.list_p
== nullptr)
528 return list_p
!= other
.list_p
;
529 return it
!= other
.it
;
533 inline bool operator==(const RTLIL::ObjIterator
<T
> &other
) const {
534 return !(*this != other
);
537 inline ObjIterator
<T
>& operator++() {
538 log_assert(list_p
!= nullptr);
539 if (++it
== list_p
->end()) {
542 refcount_p
= nullptr;
547 inline const ObjIterator
<T
> operator++(int) {
548 ObjIterator
<T
> result(*this);
557 dict
<RTLIL::IdString
, T
> *list_p
;
560 ObjRange(decltype(list_p
) list_p
, int *refcount_p
) : list_p(list_p
), refcount_p(refcount_p
) { }
561 RTLIL::ObjIterator
<T
> begin() { return RTLIL::ObjIterator
<T
>(list_p
, refcount_p
); }
562 RTLIL::ObjIterator
<T
> end() { return RTLIL::ObjIterator
<T
>(); }
563 bool contains(const RTLIL::IdString
&what
) { return (list_p
->count(what
) > 0); }
565 size_t size() const {
566 return list_p
->size();
569 operator pool
<T
>() const {
571 for (auto &it
: *list_p
)
572 result
.insert(it
.second
);
576 operator std::vector
<T
>() const {
577 std::vector
<T
> result
;
578 result
.reserve(list_p
->size());
579 for (auto &it
: *list_p
)
580 result
.push_back(it
.second
);
584 pool
<T
> to_pool() const { return *this; }
585 std::vector
<T
> to_vector() const { return *this; }
592 std::vector
<RTLIL::State
> bits
;
595 Const(std::string str
);
596 Const(int val
, int width
= 32);
597 Const(RTLIL::State bit
, int width
= 1);
598 Const(const std::vector
<RTLIL::State
> &bits
) : bits(bits
) { flags
= CONST_FLAG_NONE
; }
599 Const(const std::vector
<bool> &bits
);
600 Const(const RTLIL::Const
&c
);
601 RTLIL::Const
&operator =(const RTLIL::Const
&other
) = default;
603 bool operator <(const RTLIL::Const
&other
) const;
604 bool operator ==(const RTLIL::Const
&other
) const;
605 bool operator !=(const RTLIL::Const
&other
) const;
607 bool as_bool() const;
608 int as_int(bool is_signed
= false) const;
609 std::string
as_string() const;
610 static Const
from_string(std::string str
);
612 std::string
decode_string() const;
614 inline int size() const { return bits
.size(); }
615 inline bool empty() const { return bits
.empty(); }
616 inline RTLIL::State
&operator[](int index
) { return bits
.at(index
); }
617 inline const RTLIL::State
&operator[](int index
) const { return bits
.at(index
); }
618 inline decltype(bits
)::iterator
begin() { return bits
.begin(); }
619 inline decltype(bits
)::iterator
end() { return bits
.end(); }
621 bool is_fully_zero() const;
622 bool is_fully_ones() const;
623 bool is_fully_def() const;
624 bool is_fully_undef() const;
626 inline RTLIL::Const
extract(int offset
, int len
= 1, RTLIL::State padding
= RTLIL::State::S0
) const {
628 ret
.bits
.reserve(len
);
629 for (int i
= offset
; i
< offset
+ len
; i
++)
630 ret
.bits
.push_back(i
< GetSize(bits
) ? bits
[i
] : padding
);
634 void extu(int width
) {
635 bits
.resize(width
, RTLIL::State::S0
);
638 void exts(int width
) {
639 bits
.resize(width
, bits
.empty() ? RTLIL::State::Sx
: bits
.back());
642 inline unsigned int hash() const {
643 unsigned int h
= mkhash_init
;
650 struct RTLIL::AttrObject
652 dict
<RTLIL::IdString
, RTLIL::Const
> attributes
;
654 void set_bool_attribute(RTLIL::IdString id
, bool value
=true);
655 bool get_bool_attribute(RTLIL::IdString id
) const;
657 bool get_blackbox_attribute(bool ignore_wb
=false) const {
658 return get_bool_attribute(ID::blackbox
) || (!ignore_wb
&& get_bool_attribute(ID::whitebox
));
661 void set_strpool_attribute(RTLIL::IdString id
, const pool
<string
> &data
);
662 void add_strpool_attribute(RTLIL::IdString id
, const pool
<string
> &data
);
663 pool
<string
> get_strpool_attribute(RTLIL::IdString id
) const;
665 void set_src_attribute(const std::string
&src
);
666 std::string
get_src_attribute() const;
669 struct RTLIL::SigChunk
672 std::vector
<RTLIL::State
> data
; // only used if wire == NULL, LSB at index 0
676 SigChunk(const RTLIL::Const
&value
);
677 SigChunk(RTLIL::Wire
*wire
);
678 SigChunk(RTLIL::Wire
*wire
, int offset
, int width
= 1);
679 SigChunk(const std::string
&str
);
680 SigChunk(int val
, int width
= 32);
681 SigChunk(RTLIL::State bit
, int width
= 1);
682 SigChunk(RTLIL::SigBit bit
);
683 SigChunk(const RTLIL::SigChunk
&sigchunk
);
684 RTLIL::SigChunk
&operator =(const RTLIL::SigChunk
&other
) = default;
686 RTLIL::SigChunk
extract(int offset
, int length
) const;
687 inline int size() const { return width
; }
689 bool operator <(const RTLIL::SigChunk
&other
) const;
690 bool operator ==(const RTLIL::SigChunk
&other
) const;
691 bool operator !=(const RTLIL::SigChunk
&other
) const;
698 RTLIL::State data
; // used if wire == NULL
699 int offset
; // used if wire != NULL
703 SigBit(RTLIL::State bit
);
705 SigBit(RTLIL::Wire
*wire
);
706 SigBit(RTLIL::Wire
*wire
, int offset
);
707 SigBit(const RTLIL::SigChunk
&chunk
);
708 SigBit(const RTLIL::SigChunk
&chunk
, int index
);
709 SigBit(const RTLIL::SigSpec
&sig
);
710 SigBit(const RTLIL::SigBit
&sigbit
);
711 RTLIL::SigBit
&operator =(const RTLIL::SigBit
&other
) = default;
713 bool operator <(const RTLIL::SigBit
&other
) const;
714 bool operator ==(const RTLIL::SigBit
&other
) const;
715 bool operator !=(const RTLIL::SigBit
&other
) const;
716 unsigned int hash() const;
719 struct RTLIL::SigSpecIterator
: public std::iterator
<std::input_iterator_tag
, RTLIL::SigSpec
>
721 RTLIL::SigSpec
*sig_p
;
724 inline RTLIL::SigBit
&operator*() const;
725 inline bool operator!=(const RTLIL::SigSpecIterator
&other
) const { return index
!= other
.index
; }
726 inline bool operator==(const RTLIL::SigSpecIterator
&other
) const { return index
== other
.index
; }
727 inline void operator++() { index
++; }
730 struct RTLIL::SigSpecConstIterator
: public std::iterator
<std::input_iterator_tag
, RTLIL::SigSpec
>
732 const RTLIL::SigSpec
*sig_p
;
735 inline const RTLIL::SigBit
&operator*() const;
736 inline bool operator!=(const RTLIL::SigSpecConstIterator
&other
) const { return index
!= other
.index
; }
737 inline bool operator==(const RTLIL::SigSpecIterator
&other
) const { return index
== other
.index
; }
738 inline void operator++() { index
++; }
741 struct RTLIL::SigSpec
746 std::vector
<RTLIL::SigChunk
> chunks_
; // LSB at index 0
747 std::vector
<RTLIL::SigBit
> bits_
; // LSB at index 0
751 void updhash() const;
753 inline bool packed() const {
754 return bits_
.empty();
757 inline void inline_unpack() const {
758 if (!chunks_
.empty())
764 SigSpec(const RTLIL::SigSpec
&other
);
765 SigSpec(std::initializer_list
<RTLIL::SigSpec
> parts
);
766 const RTLIL::SigSpec
&operator=(const RTLIL::SigSpec
&other
);
768 SigSpec(const RTLIL::Const
&value
);
769 SigSpec(const RTLIL::SigChunk
&chunk
);
770 SigSpec(RTLIL::Wire
*wire
);
771 SigSpec(RTLIL::Wire
*wire
, int offset
, int width
= 1);
772 SigSpec(const std::string
&str
);
773 SigSpec(int val
, int width
= 32);
774 SigSpec(RTLIL::State bit
, int width
= 1);
775 SigSpec(RTLIL::SigBit bit
, int width
= 1);
776 SigSpec(std::vector
<RTLIL::SigChunk
> chunks
);
777 SigSpec(std::vector
<RTLIL::SigBit
> bits
);
778 SigSpec(pool
<RTLIL::SigBit
> bits
);
779 SigSpec(std::set
<RTLIL::SigBit
> bits
);
782 SigSpec(RTLIL::SigSpec
&&other
) {
783 width_
= other
.width_
;
785 chunks_
= std::move(other
.chunks_
);
786 bits_
= std::move(other
.bits_
);
789 const RTLIL::SigSpec
&operator=(RTLIL::SigSpec
&&other
) {
790 width_
= other
.width_
;
792 chunks_
= std::move(other
.chunks_
);
793 bits_
= std::move(other
.bits_
);
797 size_t get_hash() const {
802 inline const std::vector
<RTLIL::SigChunk
> &chunks() const { pack(); return chunks_
; }
803 inline const std::vector
<RTLIL::SigBit
> &bits() const { inline_unpack(); return bits_
; }
805 inline int size() const { return width_
; }
806 inline bool empty() const { return width_
== 0; }
808 inline RTLIL::SigBit
&operator[](int index
) { inline_unpack(); return bits_
.at(index
); }
809 inline const RTLIL::SigBit
&operator[](int index
) const { inline_unpack(); return bits_
.at(index
); }
811 inline RTLIL::SigSpecIterator
begin() { RTLIL::SigSpecIterator it
; it
.sig_p
= this; it
.index
= 0; return it
; }
812 inline RTLIL::SigSpecIterator
end() { RTLIL::SigSpecIterator it
; it
.sig_p
= this; it
.index
= width_
; return it
; }
814 inline RTLIL::SigSpecConstIterator
begin() const { RTLIL::SigSpecConstIterator it
; it
.sig_p
= this; it
.index
= 0; return it
; }
815 inline RTLIL::SigSpecConstIterator
end() const { RTLIL::SigSpecConstIterator it
; it
.sig_p
= this; it
.index
= width_
; return it
; }
818 void sort_and_unify();
820 void replace(const RTLIL::SigSpec
&pattern
, const RTLIL::SigSpec
&with
);
821 void replace(const RTLIL::SigSpec
&pattern
, const RTLIL::SigSpec
&with
, RTLIL::SigSpec
*other
) const;
823 void replace(const dict
<RTLIL::SigBit
, RTLIL::SigBit
> &rules
);
824 void replace(const dict
<RTLIL::SigBit
, RTLIL::SigBit
> &rules
, RTLIL::SigSpec
*other
) const;
826 void replace(const std::map
<RTLIL::SigBit
, RTLIL::SigBit
> &rules
);
827 void replace(const std::map
<RTLIL::SigBit
, RTLIL::SigBit
> &rules
, RTLIL::SigSpec
*other
) const;
829 void replace(int offset
, const RTLIL::SigSpec
&with
);
831 void remove(const RTLIL::SigSpec
&pattern
);
832 void remove(const RTLIL::SigSpec
&pattern
, RTLIL::SigSpec
*other
) const;
833 void remove2(const RTLIL::SigSpec
&pattern
, RTLIL::SigSpec
*other
);
835 void remove(const pool
<RTLIL::SigBit
> &pattern
);
836 void remove(const pool
<RTLIL::SigBit
> &pattern
, RTLIL::SigSpec
*other
) const;
837 void remove2(const pool
<RTLIL::SigBit
> &pattern
, RTLIL::SigSpec
*other
);
838 void remove2(const std::set
<RTLIL::SigBit
> &pattern
, RTLIL::SigSpec
*other
);
840 void remove(int offset
, int length
= 1);
843 RTLIL::SigSpec
extract(const RTLIL::SigSpec
&pattern
, const RTLIL::SigSpec
*other
= NULL
) const;
844 RTLIL::SigSpec
extract(const pool
<RTLIL::SigBit
> &pattern
, const RTLIL::SigSpec
*other
= NULL
) const;
845 RTLIL::SigSpec
extract(int offset
, int length
= 1) const;
846 RTLIL::SigSpec
extract_end(int offset
) const { return extract(offset
, width_
- offset
); }
848 void append(const RTLIL::SigSpec
&signal
);
849 void append_bit(const RTLIL::SigBit
&bit
);
851 void extend_u0(int width
, bool is_signed
= false);
853 RTLIL::SigSpec
repeat(int num
) const;
855 void reverse() { inline_unpack(); std::reverse(bits_
.begin(), bits_
.end()); }
857 bool operator <(const RTLIL::SigSpec
&other
) const;
858 bool operator ==(const RTLIL::SigSpec
&other
) const;
859 inline bool operator !=(const RTLIL::SigSpec
&other
) const { return !(*this == other
); }
861 bool is_wire() const;
862 bool is_chunk() const;
863 inline bool is_bit() const { return width_
== 1; }
865 bool is_fully_const() const;
866 bool is_fully_zero() const;
867 bool is_fully_ones() const;
868 bool is_fully_def() const;
869 bool is_fully_undef() const;
870 bool has_const() const;
871 bool has_marked_bits() const;
873 bool as_bool() const;
874 int as_int(bool is_signed
= false) const;
875 std::string
as_string() const;
876 RTLIL::Const
as_const() const;
877 RTLIL::Wire
*as_wire() const;
878 RTLIL::SigChunk
as_chunk() const;
879 RTLIL::SigBit
as_bit() const;
881 bool match(std::string pattern
) const;
883 std::set
<RTLIL::SigBit
> to_sigbit_set() const;
884 pool
<RTLIL::SigBit
> to_sigbit_pool() const;
885 std::vector
<RTLIL::SigBit
> to_sigbit_vector() const;
886 std::map
<RTLIL::SigBit
, RTLIL::SigBit
> to_sigbit_map(const RTLIL::SigSpec
&other
) const;
887 dict
<RTLIL::SigBit
, RTLIL::SigBit
> to_sigbit_dict(const RTLIL::SigSpec
&other
) const;
889 static bool parse(RTLIL::SigSpec
&sig
, RTLIL::Module
*module
, std::string str
);
890 static bool parse_sel(RTLIL::SigSpec
&sig
, RTLIL::Design
*design
, RTLIL::Module
*module
, std::string str
);
891 static bool parse_rhs(const RTLIL::SigSpec
&lhs
, RTLIL::SigSpec
&sig
, RTLIL::Module
*module
, std::string str
);
893 operator std::vector
<RTLIL::SigChunk
>() const { return chunks(); }
894 operator std::vector
<RTLIL::SigBit
>() const { return bits(); }
895 RTLIL::SigBit
at(int offset
, const RTLIL::SigBit
&defval
) { return offset
< width_
? (*this)[offset
] : defval
; }
897 unsigned int hash() const { if (!hash_
) updhash(); return hash_
; };
902 void check() const { }
906 struct RTLIL::Selection
909 pool
<RTLIL::IdString
> selected_modules
;
910 dict
<RTLIL::IdString
, pool
<RTLIL::IdString
>> selected_members
;
912 Selection(bool full
= true) : full_selection(full
) { }
914 bool selected_module(RTLIL::IdString mod_name
) const;
915 bool selected_whole_module(RTLIL::IdString mod_name
) const;
916 bool selected_member(RTLIL::IdString mod_name
, RTLIL::IdString memb_name
) const;
917 void optimize(RTLIL::Design
*design
);
919 template<typename T1
> void select(T1
*module
) {
920 if (!full_selection
&& selected_modules
.count(module
->name
) == 0) {
921 selected_modules
.insert(module
->name
);
922 selected_members
.erase(module
->name
);
926 template<typename T1
, typename T2
> void select(T1
*module
, T2
*member
) {
927 if (!full_selection
&& selected_modules
.count(module
->name
) == 0)
928 selected_members
[module
->name
].insert(member
->name
);
932 return !full_selection
&& selected_modules
.empty() && selected_members
.empty();
936 struct RTLIL::Monitor
938 unsigned int hashidx_
;
939 unsigned int hash() const { return hashidx_
; }
942 static unsigned int hashidx_count
= 123456789;
943 hashidx_count
= mkhash_xorshift(hashidx_count
);
944 hashidx_
= hashidx_count
;
947 virtual ~Monitor() { }
948 virtual void notify_module_add(RTLIL::Module
*) { }
949 virtual void notify_module_del(RTLIL::Module
*) { }
950 virtual void notify_connect(RTLIL::Cell
*, const RTLIL::IdString
&, const RTLIL::SigSpec
&, RTLIL::SigSpec
&) { }
951 virtual void notify_connect(RTLIL::Module
*, const RTLIL::SigSig
&) { }
952 virtual void notify_connect(RTLIL::Module
*, const std::vector
<RTLIL::SigSig
>&) { }
953 virtual void notify_blackout(RTLIL::Module
*) { }
958 unsigned int hashidx_
;
959 unsigned int hash() const { return hashidx_
; }
961 pool
<RTLIL::Monitor
*> monitors
;
962 dict
<std::string
, std::string
> scratchpad
;
964 int refcount_modules_
;
965 dict
<RTLIL::IdString
, RTLIL::Module
*> modules_
;
966 std::vector
<AST::AstNode
*> verilog_packages
, verilog_globals
;
967 dict
<std::string
, std::pair
<std::string
, bool>> verilog_defines
;
969 std::vector
<RTLIL::Selection
> selection_stack
;
970 dict
<RTLIL::IdString
, RTLIL::Selection
> selection_vars
;
971 std::string selected_active_module
;
976 RTLIL::ObjRange
<RTLIL::Module
*> modules();
977 RTLIL::Module
*module(RTLIL::IdString name
);
978 RTLIL::Module
*top_module();
980 bool has(RTLIL::IdString id
) const {
981 return modules_
.count(id
) != 0;
984 void add(RTLIL::Module
*module
);
985 RTLIL::Module
*addModule(RTLIL::IdString name
);
986 void remove(RTLIL::Module
*module
);
987 void rename(RTLIL::Module
*module
, RTLIL::IdString new_name
);
989 void scratchpad_unset(std::string varname
);
991 void scratchpad_set_int(std::string varname
, int value
);
992 void scratchpad_set_bool(std::string varname
, bool value
);
993 void scratchpad_set_string(std::string varname
, std::string value
);
995 int scratchpad_get_int(std::string varname
, int default_value
= 0) const;
996 bool scratchpad_get_bool(std::string varname
, bool default_value
= false) const;
997 std::string
scratchpad_get_string(std::string varname
, std::string default_value
= std::string()) const;
1003 bool selected_module(RTLIL::IdString mod_name
) const;
1004 bool selected_whole_module(RTLIL::IdString mod_name
) const;
1005 bool selected_member(RTLIL::IdString mod_name
, RTLIL::IdString memb_name
) const;
1007 bool selected_module(RTLIL::Module
*mod
) const;
1008 bool selected_whole_module(RTLIL::Module
*mod
) const;
1010 RTLIL::Selection
&selection() {
1011 return selection_stack
.back();
1014 const RTLIL::Selection
&selection() const {
1015 return selection_stack
.back();
1018 bool full_selection() const {
1019 return selection_stack
.back().full_selection
;
1022 template<typename T1
> bool selected(T1
*module
) const {
1023 return selected_module(module
->name
);
1026 template<typename T1
, typename T2
> bool selected(T1
*module
, T2
*member
) const {
1027 return selected_member(module
->name
, member
->name
);
1030 template<typename T1
, typename T2
> void select(T1
*module
, T2
*member
) {
1031 if (selection_stack
.size() > 0) {
1032 RTLIL::Selection
&sel
= selection_stack
.back();
1033 sel
.select(module
, member
);
1038 std::vector
<RTLIL::Module
*> selected_modules() const;
1039 std::vector
<RTLIL::Module
*> selected_whole_modules() const;
1040 std::vector
<RTLIL::Module
*> selected_whole_modules_warn() const;
1042 static std::map
<unsigned int, RTLIL::Design
*> *get_all_designs(void);
1046 struct RTLIL::Module
: public RTLIL::AttrObject
1048 unsigned int hashidx_
;
1049 unsigned int hash() const { return hashidx_
; }
1052 void add(RTLIL::Wire
*wire
);
1053 void add(RTLIL::Cell
*cell
);
1056 RTLIL::Design
*design
;
1057 pool
<RTLIL::Monitor
*> monitors
;
1059 int refcount_wires_
;
1060 int refcount_cells_
;
1062 dict
<RTLIL::IdString
, RTLIL::Wire
*> wires_
;
1063 dict
<RTLIL::IdString
, RTLIL::Cell
*> cells_
;
1064 std::vector
<RTLIL::SigSig
> connections_
;
1066 RTLIL::IdString name
;
1067 pool
<RTLIL::IdString
> avail_parameters
;
1068 dict
<RTLIL::IdString
, RTLIL::Memory
*> memories
;
1069 dict
<RTLIL::IdString
, RTLIL::Process
*> processes
;
1073 virtual RTLIL::IdString
derive(RTLIL::Design
*design
, dict
<RTLIL::IdString
, RTLIL::Const
> parameters
, bool mayfail
= false);
1074 virtual RTLIL::IdString
derive(RTLIL::Design
*design
, dict
<RTLIL::IdString
, RTLIL::Const
> parameters
, dict
<RTLIL::IdString
, RTLIL::Module
*> interfaces
, dict
<RTLIL::IdString
, RTLIL::IdString
> modports
, bool mayfail
= false);
1075 virtual size_t count_id(RTLIL::IdString id
);
1076 virtual void reprocess_module(RTLIL::Design
*design
, dict
<RTLIL::IdString
, RTLIL::Module
*> local_interfaces
);
1078 virtual void sort();
1079 virtual void check();
1080 virtual void optimize();
1081 virtual void makeblackbox();
1083 void connect(const RTLIL::SigSig
&conn
);
1084 void connect(const RTLIL::SigSpec
&lhs
, const RTLIL::SigSpec
&rhs
);
1085 void new_connections(const std::vector
<RTLIL::SigSig
> &new_conn
);
1086 const std::vector
<RTLIL::SigSig
> &connections() const;
1088 std::vector
<RTLIL::IdString
> ports
;
1091 template<typename T
> void rewrite_sigspecs(T
&functor
);
1092 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1093 void cloneInto(RTLIL::Module
*new_mod
) const;
1094 virtual RTLIL::Module
*clone() const;
1096 bool has_memories() const;
1097 bool has_processes() const;
1099 bool has_memories_warn() const;
1100 bool has_processes_warn() const;
1102 std::vector
<RTLIL::Wire
*> selected_wires() const;
1103 std::vector
<RTLIL::Cell
*> selected_cells() const;
1105 template<typename T
> bool selected(T
*member
) const {
1106 return design
->selected_member(name
, member
->name
);
1109 RTLIL::Wire
* wire(RTLIL::IdString id
) { return wires_
.count(id
) ? wires_
.at(id
) : nullptr; }
1110 RTLIL::Cell
* cell(RTLIL::IdString id
) { return cells_
.count(id
) ? cells_
.at(id
) : nullptr; }
1112 RTLIL::ObjRange
<RTLIL::Wire
*> wires() { return RTLIL::ObjRange
<RTLIL::Wire
*>(&wires_
, &refcount_wires_
); }
1113 RTLIL::ObjRange
<RTLIL::Cell
*> cells() { return RTLIL::ObjRange
<RTLIL::Cell
*>(&cells_
, &refcount_cells_
); }
1115 // Removing wires is expensive. If you have to remove wires, remove them all at once.
1116 void remove(const pool
<RTLIL::Wire
*> &wires
);
1117 void remove(RTLIL::Cell
*cell
);
1119 void rename(RTLIL::Wire
*wire
, RTLIL::IdString new_name
);
1120 void rename(RTLIL::Cell
*cell
, RTLIL::IdString new_name
);
1121 void rename(RTLIL::IdString old_name
, RTLIL::IdString new_name
);
1123 void swap_names(RTLIL::Wire
*w1
, RTLIL::Wire
*w2
);
1124 void swap_names(RTLIL::Cell
*c1
, RTLIL::Cell
*c2
);
1126 RTLIL::IdString
uniquify(RTLIL::IdString name
);
1127 RTLIL::IdString
uniquify(RTLIL::IdString name
, int &index
);
1129 RTLIL::Wire
*addWire(RTLIL::IdString name
, int width
= 1);
1130 RTLIL::Wire
*addWire(RTLIL::IdString name
, const RTLIL::Wire
*other
);
1132 RTLIL::Cell
*addCell(RTLIL::IdString name
, RTLIL::IdString type
);
1133 RTLIL::Cell
*addCell(RTLIL::IdString name
, const RTLIL::Cell
*other
);
1135 // The add* methods create a cell and return the created cell. All signals must exist in advance.
1137 RTLIL::Cell
* addNot (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1138 RTLIL::Cell
* addPos (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1139 RTLIL::Cell
* addNeg (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1141 RTLIL::Cell
* addAnd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1142 RTLIL::Cell
* addOr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1143 RTLIL::Cell
* addXor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1144 RTLIL::Cell
* addXnor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1146 RTLIL::Cell
* addReduceAnd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1147 RTLIL::Cell
* addReduceOr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1148 RTLIL::Cell
* addReduceXor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1149 RTLIL::Cell
* addReduceXnor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1150 RTLIL::Cell
* addReduceBool (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1152 RTLIL::Cell
* addShl (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1153 RTLIL::Cell
* addShr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1154 RTLIL::Cell
* addSshl (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1155 RTLIL::Cell
* addSshr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1156 RTLIL::Cell
* addShift (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1157 RTLIL::Cell
* addShiftx (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1159 RTLIL::Cell
* addLt (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1160 RTLIL::Cell
* addLe (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1161 RTLIL::Cell
* addEq (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1162 RTLIL::Cell
* addNe (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1163 RTLIL::Cell
* addEqx (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1164 RTLIL::Cell
* addNex (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1165 RTLIL::Cell
* addGe (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1166 RTLIL::Cell
* addGt (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1168 RTLIL::Cell
* addAdd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1169 RTLIL::Cell
* addSub (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1170 RTLIL::Cell
* addMul (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1171 RTLIL::Cell
* addDiv (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1172 RTLIL::Cell
* addMod (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1173 RTLIL::Cell
* addPow (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool a_signed
= false, bool b_signed
= false, const std::string
&src
= "");
1175 RTLIL::Cell
* addLogicNot (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1176 RTLIL::Cell
* addLogicAnd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1177 RTLIL::Cell
* addLogicOr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, bool is_signed
= false, const std::string
&src
= "");
1179 RTLIL::Cell
* addMux (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_s
, RTLIL::SigSpec sig_y
, const std::string
&src
= "");
1180 RTLIL::Cell
* addPmux (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_s
, RTLIL::SigSpec sig_y
, const std::string
&src
= "");
1182 RTLIL::Cell
* addSlice (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, RTLIL::Const offset
, const std::string
&src
= "");
1183 RTLIL::Cell
* addConcat (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, const std::string
&src
= "");
1184 RTLIL::Cell
* addLut (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_y
, RTLIL::Const lut
, const std::string
&src
= "");
1185 RTLIL::Cell
* addTribuf (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_y
, const std::string
&src
= "");
1186 RTLIL::Cell
* addAssert (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, const std::string
&src
= "");
1187 RTLIL::Cell
* addAssume (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, const std::string
&src
= "");
1188 RTLIL::Cell
* addLive (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, const std::string
&src
= "");
1189 RTLIL::Cell
* addFair (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, const std::string
&src
= "");
1190 RTLIL::Cell
* addCover (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_en
, const std::string
&src
= "");
1191 RTLIL::Cell
* addEquiv (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_y
, const std::string
&src
= "");
1193 RTLIL::Cell
* addSr (RTLIL::IdString name
, RTLIL::SigSpec sig_set
, RTLIL::SigSpec sig_clr
, RTLIL::SigSpec sig_q
, bool set_polarity
= true, bool clr_polarity
= true, const std::string
&src
= "");
1194 RTLIL::Cell
* addFf (RTLIL::IdString name
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, const std::string
&src
= "");
1195 RTLIL::Cell
* addDff (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, const std::string
&src
= "");
1196 RTLIL::Cell
* addDffe (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, bool en_polarity
= true, const std::string
&src
= "");
1197 RTLIL::Cell
* addDffsr (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_set
, RTLIL::SigSpec sig_clr
,
1198 RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, bool set_polarity
= true, bool clr_polarity
= true, const std::string
&src
= "");
1199 RTLIL::Cell
* addAdff (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_arst
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
,
1200 RTLIL::Const arst_value
, bool clk_polarity
= true, bool arst_polarity
= true, const std::string
&src
= "");
1201 RTLIL::Cell
* addDlatch (RTLIL::IdString name
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool en_polarity
= true, const std::string
&src
= "");
1202 RTLIL::Cell
* addDlatchsr (RTLIL::IdString name
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_set
, RTLIL::SigSpec sig_clr
,
1203 RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool en_polarity
= true, bool set_polarity
= true, bool clr_polarity
= true, const std::string
&src
= "");
1205 RTLIL::Cell
* addBufGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1206 RTLIL::Cell
* addNotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1207 RTLIL::Cell
* addAndGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1208 RTLIL::Cell
* addNandGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1209 RTLIL::Cell
* addOrGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1210 RTLIL::Cell
* addNorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1211 RTLIL::Cell
* addXorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1212 RTLIL::Cell
* addXnorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1213 RTLIL::Cell
* addAndnotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1214 RTLIL::Cell
* addOrnotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1215 RTLIL::Cell
* addMuxGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_s
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1216 RTLIL::Cell
* addNmuxGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_s
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1217 RTLIL::Cell
* addAoi3Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1218 RTLIL::Cell
* addOai3Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1219 RTLIL::Cell
* addAoi4Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_d
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1220 RTLIL::Cell
* addOai4Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_d
, RTLIL::SigBit sig_y
, const std::string
&src
= "");
1222 RTLIL::Cell
* addFfGate (RTLIL::IdString name
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, const std::string
&src
= "");
1223 RTLIL::Cell
* addDffGate (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, const std::string
&src
= "");
1224 RTLIL::Cell
* addDffeGate (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, bool en_polarity
= true, const std::string
&src
= "");
1225 RTLIL::Cell
* addDffsrGate (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_set
, RTLIL::SigSpec sig_clr
,
1226 RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool clk_polarity
= true, bool set_polarity
= true, bool clr_polarity
= true, const std::string
&src
= "");
1227 RTLIL::Cell
* addAdffGate (RTLIL::IdString name
, RTLIL::SigSpec sig_clk
, RTLIL::SigSpec sig_arst
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
,
1228 bool arst_value
= false, bool clk_polarity
= true, bool arst_polarity
= true, const std::string
&src
= "");
1229 RTLIL::Cell
* addDlatchGate (RTLIL::IdString name
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool en_polarity
= true, const std::string
&src
= "");
1230 RTLIL::Cell
* addDlatchsrGate (RTLIL::IdString name
, RTLIL::SigSpec sig_en
, RTLIL::SigSpec sig_set
, RTLIL::SigSpec sig_clr
,
1231 RTLIL::SigSpec sig_d
, RTLIL::SigSpec sig_q
, bool en_polarity
= true, bool set_polarity
= true, bool clr_polarity
= true, const std::string
&src
= "");
1233 // The methods without the add* prefix create a cell and an output signal. They return the newly created output signal.
1235 RTLIL::SigSpec
Not (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1236 RTLIL::SigSpec
Pos (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1237 RTLIL::SigSpec
Bu0 (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1238 RTLIL::SigSpec
Neg (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1240 RTLIL::SigSpec
And (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1241 RTLIL::SigSpec
Or (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1242 RTLIL::SigSpec
Xor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1243 RTLIL::SigSpec
Xnor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1245 RTLIL::SigSpec
ReduceAnd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1246 RTLIL::SigSpec
ReduceOr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1247 RTLIL::SigSpec
ReduceXor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1248 RTLIL::SigSpec
ReduceXnor (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1249 RTLIL::SigSpec
ReduceBool (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1251 RTLIL::SigSpec
Shl (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1252 RTLIL::SigSpec
Shr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1253 RTLIL::SigSpec
Sshl (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1254 RTLIL::SigSpec
Sshr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1255 RTLIL::SigSpec
Shift (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1256 RTLIL::SigSpec
Shiftx (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1258 RTLIL::SigSpec
Lt (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1259 RTLIL::SigSpec
Le (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1260 RTLIL::SigSpec
Eq (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1261 RTLIL::SigSpec
Ne (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1262 RTLIL::SigSpec
Eqx (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1263 RTLIL::SigSpec
Nex (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1264 RTLIL::SigSpec
Ge (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1265 RTLIL::SigSpec
Gt (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1267 RTLIL::SigSpec
Add (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1268 RTLIL::SigSpec
Sub (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1269 RTLIL::SigSpec
Mul (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1270 RTLIL::SigSpec
Div (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1271 RTLIL::SigSpec
Mod (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1272 RTLIL::SigSpec
Pow (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool a_signed
= false, bool b_signed
= false, const std::string
&src
= "");
1274 RTLIL::SigSpec
LogicNot (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, bool is_signed
= false, const std::string
&src
= "");
1275 RTLIL::SigSpec
LogicAnd (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1276 RTLIL::SigSpec
LogicOr (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, bool is_signed
= false, const std::string
&src
= "");
1278 RTLIL::SigSpec
Mux (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_s
, const std::string
&src
= "");
1279 RTLIL::SigSpec
Pmux (RTLIL::IdString name
, RTLIL::SigSpec sig_a
, RTLIL::SigSpec sig_b
, RTLIL::SigSpec sig_s
, const std::string
&src
= "");
1281 RTLIL::SigBit
BufGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, const std::string
&src
= "");
1282 RTLIL::SigBit
NotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, const std::string
&src
= "");
1283 RTLIL::SigBit
AndGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1284 RTLIL::SigBit
NandGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1285 RTLIL::SigBit
OrGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1286 RTLIL::SigBit
NorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1287 RTLIL::SigBit
XorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1288 RTLIL::SigBit
XnorGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1289 RTLIL::SigBit
AndnotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1290 RTLIL::SigBit
OrnotGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, const std::string
&src
= "");
1291 RTLIL::SigBit
MuxGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_s
, const std::string
&src
= "");
1292 RTLIL::SigBit
NmuxGate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_s
, const std::string
&src
= "");
1293 RTLIL::SigBit
Aoi3Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, const std::string
&src
= "");
1294 RTLIL::SigBit
Oai3Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, const std::string
&src
= "");
1295 RTLIL::SigBit
Aoi4Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_d
, const std::string
&src
= "");
1296 RTLIL::SigBit
Oai4Gate (RTLIL::IdString name
, RTLIL::SigBit sig_a
, RTLIL::SigBit sig_b
, RTLIL::SigBit sig_c
, RTLIL::SigBit sig_d
, const std::string
&src
= "");
1298 RTLIL::SigSpec
Anyconst (RTLIL::IdString name
, int width
= 1, const std::string
&src
= "");
1299 RTLIL::SigSpec
Anyseq (RTLIL::IdString name
, int width
= 1, const std::string
&src
= "");
1300 RTLIL::SigSpec
Allconst (RTLIL::IdString name
, int width
= 1, const std::string
&src
= "");
1301 RTLIL::SigSpec
Allseq (RTLIL::IdString name
, int width
= 1, const std::string
&src
= "");
1302 RTLIL::SigSpec
Initstate (RTLIL::IdString name
, const std::string
&src
= "");
1305 static std::map
<unsigned int, RTLIL::Module
*> *get_all_modules(void);
1309 struct RTLIL::Wire
: public RTLIL::AttrObject
1311 unsigned int hashidx_
;
1312 unsigned int hash() const { return hashidx_
; }
1315 // use module->addWire() and module->remove() to create or destroy wires
1316 friend struct RTLIL::Module
;
1321 // do not simply copy wires
1322 Wire(RTLIL::Wire
&other
) = delete;
1323 void operator=(RTLIL::Wire
&other
) = delete;
1325 RTLIL::Module
*module
;
1326 RTLIL::IdString name
;
1327 int width
, start_offset
, port_id
;
1328 bool port_input
, port_output
, upto
;
1331 static std::map
<unsigned int, RTLIL::Wire
*> *get_all_wires(void);
1335 struct RTLIL::Memory
: public RTLIL::AttrObject
1337 unsigned int hashidx_
;
1338 unsigned int hash() const { return hashidx_
; }
1342 RTLIL::IdString name
;
1343 int width
, start_offset
, size
;
1346 static std::map
<unsigned int, RTLIL::Memory
*> *get_all_memorys(void);
1350 struct RTLIL::Cell
: public RTLIL::AttrObject
1352 unsigned int hashidx_
;
1353 unsigned int hash() const { return hashidx_
; }
1356 // use module->addCell() and module->remove() to create or destroy cells
1357 friend struct RTLIL::Module
;
1362 // do not simply copy cells
1363 Cell(RTLIL::Cell
&other
) = delete;
1364 void operator=(RTLIL::Cell
&other
) = delete;
1366 RTLIL::Module
*module
;
1367 RTLIL::IdString name
;
1368 RTLIL::IdString type
;
1369 dict
<RTLIL::IdString
, RTLIL::SigSpec
> connections_
;
1370 dict
<RTLIL::IdString
, RTLIL::Const
> parameters
;
1372 // access cell ports
1373 bool hasPort(RTLIL::IdString portname
) const;
1374 void unsetPort(RTLIL::IdString portname
);
1375 void setPort(RTLIL::IdString portname
, RTLIL::SigSpec signal
);
1376 const RTLIL::SigSpec
&getPort(RTLIL::IdString portname
) const;
1377 const dict
<RTLIL::IdString
, RTLIL::SigSpec
> &connections() const;
1379 // information about cell ports
1381 bool input(RTLIL::IdString portname
) const;
1382 bool output(RTLIL::IdString portname
) const;
1384 // access cell parameters
1385 bool hasParam(RTLIL::IdString paramname
) const;
1386 void unsetParam(RTLIL::IdString paramname
);
1387 void setParam(RTLIL::IdString paramname
, RTLIL::Const value
);
1388 const RTLIL::Const
&getParam(RTLIL::IdString paramname
) const;
1392 void fixup_parameters(bool set_a_signed
= false, bool set_b_signed
= false);
1394 bool has_keep_attr() const {
1395 return get_bool_attribute(ID::keep
) || (module
&& module
->design
&& module
->design
->module(type
) &&
1396 module
->design
->module(type
)->get_bool_attribute(ID::keep
));
1399 template<typename T
> void rewrite_sigspecs(T
&functor
);
1400 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1403 static std::map
<unsigned int, RTLIL::Cell
*> *get_all_cells(void);
1407 struct RTLIL::CaseRule
: public RTLIL::AttrObject
1409 std::vector
<RTLIL::SigSpec
> compare
;
1410 std::vector
<RTLIL::SigSig
> actions
;
1411 std::vector
<RTLIL::SwitchRule
*> switches
;
1418 template<typename T
> void rewrite_sigspecs(T
&functor
);
1419 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1420 RTLIL::CaseRule
*clone() const;
1423 struct RTLIL::SwitchRule
: public RTLIL::AttrObject
1425 RTLIL::SigSpec signal
;
1426 std::vector
<RTLIL::CaseRule
*> cases
;
1432 template<typename T
> void rewrite_sigspecs(T
&functor
);
1433 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1434 RTLIL::SwitchRule
*clone() const;
1437 struct RTLIL::SyncRule
1439 RTLIL::SyncType type
;
1440 RTLIL::SigSpec signal
;
1441 std::vector
<RTLIL::SigSig
> actions
;
1443 template<typename T
> void rewrite_sigspecs(T
&functor
);
1444 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1445 RTLIL::SyncRule
*clone() const;
1448 struct RTLIL::Process
: public RTLIL::AttrObject
1450 RTLIL::IdString name
;
1451 RTLIL::CaseRule root_case
;
1452 std::vector
<RTLIL::SyncRule
*> syncs
;
1456 template<typename T
> void rewrite_sigspecs(T
&functor
);
1457 template<typename T
> void rewrite_sigspecs2(T
&functor
);
1458 RTLIL::Process
*clone() const;
1462 inline RTLIL::SigBit::SigBit() : wire(NULL
), data(RTLIL::State::S0
) { }
1463 inline RTLIL::SigBit::SigBit(RTLIL::State bit
) : wire(NULL
), data(bit
) { }
1464 inline RTLIL::SigBit::SigBit(bool bit
) : wire(NULL
), data(bit
? State::S1
: State::S0
) { }
1465 inline RTLIL::SigBit::SigBit(RTLIL::Wire
*wire
) : wire(wire
), offset(0) { log_assert(wire
&& wire
->width
== 1); }
1466 inline RTLIL::SigBit::SigBit(RTLIL::Wire
*wire
, int offset
) : wire(wire
), offset(offset
) { log_assert(wire
!= nullptr); }
1467 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]; }
1468 inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk
&chunk
, int index
) : wire(chunk
.wire
) { if (wire
) offset
= chunk
.offset
+ index
; else data
= chunk
.data
[index
]; }
1469 inline RTLIL::SigBit::SigBit(const RTLIL::SigBit
&sigbit
) : wire(sigbit
.wire
), data(sigbit
.data
){if(wire
) offset
= sigbit
.offset
;}
1471 inline bool RTLIL::SigBit::operator<(const RTLIL::SigBit
&other
) const {
1472 if (wire
== other
.wire
)
1473 return wire
? (offset
< other
.offset
) : (data
< other
.data
);
1474 if (wire
!= nullptr && other
.wire
!= nullptr)
1475 return wire
->name
< other
.wire
->name
;
1476 return (wire
!= nullptr) < (other
.wire
!= nullptr);
1479 inline bool RTLIL::SigBit::operator==(const RTLIL::SigBit
&other
) const {
1480 return (wire
== other
.wire
) && (wire
? (offset
== other
.offset
) : (data
== other
.data
));
1483 inline bool RTLIL::SigBit::operator!=(const RTLIL::SigBit
&other
) const {
1484 return (wire
!= other
.wire
) || (wire
? (offset
!= other
.offset
) : (data
!= other
.data
));
1487 inline unsigned int RTLIL::SigBit::hash() const {
1489 return mkhash_add(wire
->name
.hash(), offset
);
1493 inline RTLIL::SigBit
&RTLIL::SigSpecIterator::operator*() const {
1494 return (*sig_p
)[index
];
1497 inline const RTLIL::SigBit
&RTLIL::SigSpecConstIterator::operator*() const {
1498 return (*sig_p
)[index
];
1501 inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec
&sig
) {
1502 log_assert(sig
.size() == 1 && sig
.chunks().size() == 1);
1503 *this = SigBit(sig
.chunks().front());
1506 template<typename T
>
1507 void RTLIL::Module::rewrite_sigspecs(T
&functor
)
1509 for (auto &it
: cells_
)
1510 it
.second
->rewrite_sigspecs(functor
);
1511 for (auto &it
: processes
)
1512 it
.second
->rewrite_sigspecs(functor
);
1513 for (auto &it
: connections_
) {
1519 template<typename T
>
1520 void RTLIL::Module::rewrite_sigspecs2(T
&functor
)
1522 for (auto &it
: cells_
)
1523 it
.second
->rewrite_sigspecs2(functor
);
1524 for (auto &it
: processes
)
1525 it
.second
->rewrite_sigspecs2(functor
);
1526 for (auto &it
: connections_
) {
1527 functor(it
.first
, it
.second
);
1531 template<typename T
>
1532 void RTLIL::Cell::rewrite_sigspecs(T
&functor
) {
1533 for (auto &it
: connections_
)
1537 template<typename T
>
1538 void RTLIL::Cell::rewrite_sigspecs2(T
&functor
) {
1539 for (auto &it
: connections_
)
1543 template<typename T
>
1544 void RTLIL::CaseRule::rewrite_sigspecs(T
&functor
) {
1545 for (auto &it
: compare
)
1547 for (auto &it
: actions
) {
1551 for (auto it
: switches
)
1552 it
->rewrite_sigspecs(functor
);
1555 template<typename T
>
1556 void RTLIL::CaseRule::rewrite_sigspecs2(T
&functor
) {
1557 for (auto &it
: compare
)
1559 for (auto &it
: actions
) {
1560 functor(it
.first
, it
.second
);
1562 for (auto it
: switches
)
1563 it
->rewrite_sigspecs2(functor
);
1566 template<typename T
>
1567 void RTLIL::SwitchRule::rewrite_sigspecs(T
&functor
)
1570 for (auto it
: cases
)
1571 it
->rewrite_sigspecs(functor
);
1574 template<typename T
>
1575 void RTLIL::SwitchRule::rewrite_sigspecs2(T
&functor
)
1578 for (auto it
: cases
)
1579 it
->rewrite_sigspecs2(functor
);
1582 template<typename T
>
1583 void RTLIL::SyncRule::rewrite_sigspecs(T
&functor
)
1586 for (auto &it
: actions
) {
1592 template<typename T
>
1593 void RTLIL::SyncRule::rewrite_sigspecs2(T
&functor
)
1596 for (auto &it
: actions
) {
1597 functor(it
.first
, it
.second
);
1601 template<typename T
>
1602 void RTLIL::Process::rewrite_sigspecs(T
&functor
)
1604 root_case
.rewrite_sigspecs(functor
);
1605 for (auto it
: syncs
)
1606 it
->rewrite_sigspecs(functor
);
1609 template<typename T
>
1610 void RTLIL::Process::rewrite_sigspecs2(T
&functor
)
1612 root_case
.rewrite_sigspecs2(functor
);
1613 for (auto it
: syncs
)
1614 it
->rewrite_sigspecs2(functor
);