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> &parameters, bool mayfail = false);
1164 	virtual RTLIL::IdString derive(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Const> &parameters, 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