Merge branch 'master' of https://github.com/cliffordwolf/yosys into btor

added case for memwr cell that is used in muxes (same cell is used more than one time)
corrected bug for xnor and logic_not
added pmux cell translation

Conflicts:
	backends/btor/btor.cc

1 files changed, 799 insertions, 123 deletions

diff --git a/kernel/rtlil.h b/kernel/rtlil.h
index caadf1981..a0ae8f082 100644
--- a/kernel/rtlil.h
+++ b/kernel/rtlil.h
@@ -17,20 +17,16 @@
  *
  */
 
+#include "kernel/yosys.h"
+
 #ifndef RTLIL_H
 #define RTLIL_H
 
-#include <map>
-#include <set>
-#include <vector>
-#include <string>
-#include <assert.h>
-
-std::string stringf(const char *fmt, ...);
+YOSYS_NAMESPACE_BEGIN
 
 namespace RTLIL
 {
-	enum State {
+	enum State : unsigned char {
 		S0 = 0,
 		S1 = 1,
 		Sx = 2, // undefined value or conflict
@@ -39,7 +35,7 @@ namespace RTLIL
 		Sm = 5  // marker (used internally by some passes)
 	};
 
-	enum SyncType {
+	enum SyncType : unsigned char {
 		ST0 = 0, // level sensitive: 0
 		ST1 = 1, // level sensitive: 1
 		STp = 2, // edge sensitive: posedge
@@ -49,17 +45,16 @@ namespace RTLIL
 		STi = 6  // init
 	};
 
-	enum ConstFlags {
+	enum ConstFlags : unsigned char {
 		CONST_FLAG_NONE   = 0,
 		CONST_FLAG_STRING = 1,
 		CONST_FLAG_SIGNED = 2,  // only used for parameters
 		CONST_FLAG_REAL   = 4   // unused -- to be used for parameters
 	};
 
-	extern int autoidx;
-
 	struct Const;
 	struct Selection;
+	struct Monitor;
 	struct Design;
 	struct Module;
 	struct Wire;
@@ -67,6 +62,8 @@ namespace RTLIL
 	struct Cell;
 	struct SigChunk;
 	struct SigBit;
+	struct SigSpecIterator;
+	struct SigSpecConstIterator;
 	struct SigSpec;
 	struct CaseRule;
 	struct SwitchRule;
@@ -75,79 +72,207 @@ namespace RTLIL
 
 	typedef std::pair<SigSpec, SigSpec> SigSig;
 
-#ifdef NDEBUG
-	typedef std::string IdString;
-#else
-	struct IdString : public std::string {
-		IdString() { }
-		IdString(std::string str) : std::string(str) {
-			check();
+	struct IdString
+	{
+		// the global id string cache
+
+		struct char_ptr_cmp {
+			bool operator()(const char *a, const char *b) const {
+				for (int i = 0; a[i] || b[i]; i++)
+					if (a[i] != b[i])
+						return a[i] < b[i];
+				return false;
+			}
+		};
+
+		static std::vector<int> global_refcount_storage_;
+		static std::vector<char*> global_id_storage_;
+		static std::map<char*, int, char_ptr_cmp> global_id_index_;
+		static std::vector<int> global_free_idx_list_;
+
+		static inline int get_reference(int idx)
+		{
+			global_refcount_storage_.at(idx)++;
+			return idx;
 		}
-		IdString(const char *s) : std::string(s) {
-			check();
+
+		static inline int get_reference(const char *p)
+		{
+			if (p[0]) {
+				log_assert(p[1] != 0);
+				log_assert(p[0] == '$' || p[0] == '\\');
+			}
+
+			auto it = global_id_index_.find((char*)p);
+			if (it != global_id_index_.end()) {
+				global_refcount_storage_.at(it->second)++;
+				return it->second;
+			}
+
+			if (global_free_idx_list_.empty()) {
+				log_assert(global_id_storage_.size() < 0x40000000);
+				global_free_idx_list_.push_back(global_id_storage_.size());
+				global_id_storage_.push_back(nullptr);
+				global_refcount_storage_.push_back(0);
+			}
+
+			int idx = global_free_idx_list_.back();
+			global_free_idx_list_.pop_back();
+			global_id_storage_.at(idx) = strdup(p);
+			global_id_index_[global_id_storage_.at(idx)] = idx;
+			global_refcount_storage_.at(idx)++;
+			return idx;
 		}
-		IdString &operator=(const std::string &str) {
-			std::string::operator=(str);
-			check();
-			return *this;
+
+		static inline void put_reference(int idx)
+		{
+			log_assert(global_refcount_storage_.at(idx) > 0);
+
+			if (--global_refcount_storage_.at(idx) != 0)
+				return;
+
+			global_id_index_.erase(global_id_storage_.at(idx));
+			free(global_id_storage_.at(idx));
+			global_id_storage_.at(idx) = nullptr;
+			global_free_idx_list_.push_back(idx);
 		}
-		IdString &operator=(const char *s) {
-			std::string::operator=(s);
-			check();
-			return *this;
+
+		// the actual IdString object is just is a single int
+
+		int index_;
+
+		IdString() : index_(get_reference("")) { }
+		IdString(const char *str) : index_(get_reference(str)) { }
+		IdString(const IdString &str) : index_(get_reference(str.index_)) { }
+		IdString(const std::string &str) : index_(get_reference(str.c_str())) { }
+		~IdString() { put_reference(index_); }
+
+		void operator=(const IdString &rhs) {
+			put_reference(index_);
+			index_ = get_reference(rhs.index_);
+		}
+
+		void operator=(const char *rhs) {
+			IdString id(rhs);
+			*this = id;
+		}
+
+		void operator=(const std::string &rhs) {
+			IdString id(rhs);
+			*this = id;
+		}
+
+		const char *c_str() const {
+			return global_id_storage_.at(index_);
 		}
-		bool operator<(const IdString &rhs) {
-			check(), rhs.check();
-			return std::string(*this) < std::string(rhs);
+
+		std::string str() const {
+			return std::string(global_id_storage_.at(index_));
 		}
-		void check() const {
-			assert(empty() || (size() >= 2 && (at(0) == '$' || at(0) == '\\')));
+
+		bool operator<(IdString rhs) const {
+			return index_ < rhs.index_;
 		}
+
+		bool operator==(IdString rhs) const { return index_ == rhs.index_; }
+		bool operator!=(IdString rhs) const { return index_ != rhs.index_; }
+
+		// The methods below are just convinience functions for better compatibility with std::string.
+
+		bool operator==(const std::string &rhs) const { return str() == rhs; }
+		bool operator!=(const std::string &rhs) const { return str() != rhs; }
+
+		bool operator==(const char *rhs) const { return strcmp(c_str(), rhs) == 0; }
+		bool operator!=(const char *rhs) const { return strcmp(c_str(), rhs) != 0; }
+
+		char operator[](size_t i) const {
+			const char *p = c_str();
+			for (; i != 0; i--, p++) 
+				log_assert(*p != 0);
+			return *p;
+		}
+
+		std::string substr(size_t pos = 0, size_t len = std::string::npos) const {
+			if (len == std::string::npos || len >= strlen(c_str() + pos))
+				return std::string(c_str() + pos);
+			else
+				return std::string(c_str() + pos, len);
+		}
+
+		size_t size() const {
+			return str().size();
+		}
+
+		bool empty() const {
+			return c_str()[0] == 0;
+		}
+
+		void clear() {
+			*this = IdString();
+		}
+
+		// The following is a helper key_compare class. Instead of for example std::set<Cell*>
+		// use std::set<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the
+		// set has an influence on the algorithm.
+
+		template<typename T> struct compare_ptr_by_name {
+			bool operator()(const T *a, const T *b) {
+				return (a == nullptr || b == nullptr) ? (a < b) : (a->name < b->name);
+			}
+		};
+
+		// often one needs to check if a given IdString is part of a list (for example a list
+		// of cell types). the following functions helps with that.
+
+		template<typename T, typename... Args>
+		bool in(T first, Args... rest) {
+			return in(first) || in(rest...);
+		}
+
+		bool in(IdString rhs) { return *this == rhs; }
+		bool in(const char *rhs) { return *this == rhs; }
+		bool in(const std::string &rhs) { return *this == rhs; }
+		bool in(const std::set<IdString> &rhs) { return rhs.count(*this) != 0; }
 	};
-#endif
 
-	static IdString escape_id(std::string str) __attribute__((unused));
-	static IdString escape_id(std::string str) {
+	static inline std::string escape_id(std::string str) {
 		if (str.size() > 0 && str[0] != '\\' && str[0] != '$')
 			return "\\" + str;
 		return str;
 	}
 
-	static std::string unescape_id(std::string str) __attribute__((unused));
-	static std::string unescape_id(std::string str) {
+	static inline std::string unescape_id(std::string str) {
 		if (str.size() > 1 && str[0] == '\\' && str[1] != '$')
 			return str.substr(1);
 		return str;
 	}
 
-	static const char *id2cstr(std::string str) __attribute__((unused));
-	static const char *id2cstr(std::string str) {
-		if (str.size() > 1 && str[0] == '\\' && str[1] != '$')
-			return str.c_str() + 1;
-		return str.c_str();
+	static inline std::string unescape_id(RTLIL::IdString str) {
+		return unescape_id(str.str());
 	}
 
-	static IdString new_id(std::string file, int line, std::string func) __attribute__((unused));
-	static IdString new_id(std::string file, int line, std::string func) {
-		std::string str = "$auto$";
-		size_t pos = file.find_last_of('/');
-		str += pos != std::string::npos ? file.substr(pos+1) : file;
-		str += stringf(":%d:%s$%d", line, func.c_str(), autoidx++);
-		return str;
+	static inline const char *id2cstr(const RTLIL::IdString &str) {
+		return log_id(str);
 	}
 
-#define NEW_ID \
-	RTLIL::new_id(__FILE__, __LINE__, __FUNCTION__)
-
-#define NEW_WIRE(_mod, _width) \
-	(_mod)->new_wire(_width, NEW_ID)
-
-	template <typename T> struct sort_by_name {
+	template <typename T> struct sort_by_name_id {
 		bool operator()(T *a, T *b) const {
 			return a->name < b->name;
 		}
 	};
 
+	template <typename T> struct sort_by_name_str {
+		bool operator()(T *a, T *b) const {
+			return strcmp(a->name.c_str(), b->name.c_str()) < 0;
+		}
+	};
+
+	struct sort_by_id_str {
+		bool operator()(RTLIL::IdString a, RTLIL::IdString b) const {
+			return strcmp(a.c_str(), b.c_str()) < 0;
+		}
+	};
+
 	// see calc.cc for the implementation of this functions
 	RTLIL::Const const_not         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 	RTLIL::Const const_and         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
@@ -169,6 +294,8 @@ namespace RTLIL
 	RTLIL::Const const_shr         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 	RTLIL::Const const_sshl        (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 	RTLIL::Const const_sshr        (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
+	RTLIL::Const const_shift       (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
+	RTLIL::Const const_shiftx      (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 
 	RTLIL::Const const_lt          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 	RTLIL::Const const_le          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
@@ -187,77 +314,245 @@ namespace RTLIL
 	RTLIL::Const const_pow         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 
 	RTLIL::Const const_pos         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
-	RTLIL::Const const_bu0         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 	RTLIL::Const const_neg         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
+
+
+	// This iterator-range-pair is used for Design::modules(), Module::wires() and Module::cells().
+	// It maintains a reference counter that is used to make sure that the container is not modified while being iterated over.
+
+	template<typename T>
+	struct ObjIterator
+	{
+		typename std::map<RTLIL::IdString, T>::iterator it;
+		std::map<RTLIL::IdString, T> *list_p;
+		int *refcount_p;
+
+		ObjIterator() : list_p(nullptr), refcount_p(nullptr) {
+		}
+
+		ObjIterator(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) {
+			if (list_p->empty()) {
+				this->list_p = nullptr;
+				this->refcount_p = nullptr;
+			} else {
+				it = list_p->begin();
+				(*refcount_p)++;
+			}
+		}
+
+		ObjIterator(const RTLIL::ObjIterator<T> &other) {
+			it = other.it;
+			list_p = other.list_p;
+			refcount_p = other.refcount_p;
+			if (refcount_p)
+				(*refcount_p)++;
+		}
+
+		ObjIterator &operator=(const RTLIL::ObjIterator<T> &other) {
+			if (refcount_p)
+				(*refcount_p)--;
+			it = other.it;
+			list_p = other.list_p;
+			refcount_p = other.refcount_p;
+			if (refcount_p)
+				(*refcount_p)++;
+			return *this;
+		}
+
+		~ObjIterator() {
+			if (refcount_p)
+				(*refcount_p)--;
+		}
+
+		inline T operator*() const {
+			log_assert(list_p != nullptr);
+			return it->second;
+		}
+
+		inline bool operator!=(const RTLIL::ObjIterator<T> &other) const {
+			if (list_p == nullptr || other.list_p == nullptr)
+				return list_p != other.list_p;
+			return it != other.it;
+		}
+
+		inline void operator++() {
+			log_assert(list_p != nullptr);
+			if (++it == list_p->end()) {
+				(*refcount_p)--;
+				list_p = nullptr;
+				refcount_p = nullptr;
+			}
+		}
+	};
+
+	template<typename T>
+	struct ObjRange
+	{
+		std::map<RTLIL::IdString, T> *list_p;
+		int *refcount_p;
+
+		ObjRange(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) { }
+		RTLIL::ObjIterator<T> begin() { return RTLIL::ObjIterator<T>(list_p, refcount_p); }
+		RTLIL::ObjIterator<T> end() { return RTLIL::ObjIterator<T>(); }
+
+		size_t size() const {
+			return list_p->size();
+		}
+
+		operator std::set<T>() const {
+			std::set<T> result;
+			for (auto &it : *list_p)
+				result.insert(it.second);
+			return result;
+		}
+
+		operator std::vector<T>() const {
+			std::vector<T> result;
+			result.reserve(list_p->size());
+			for (auto &it : *list_p)
+				result.push_back(it.second);
+			return result;
+		}
+
+		std::set<T> to_set() const { return *this; }
+		std::vector<T> to_vector() const { return *this; }
+	};
 };
 
-struct RTLIL::Const {
+struct RTLIL::Const
+{
 	int flags;
 	std::vector<RTLIL::State> bits;
+
 	Const();
 	Const(std::string str);
 	Const(int val, int width = 32);
 	Const(RTLIL::State bit, int width = 1);
-	Const(std::vector<RTLIL::State> bits) : bits(bits) { flags = CONST_FLAG_NONE; };
+	Const(const std::vector<RTLIL::State> &bits) : bits(bits) { flags = CONST_FLAG_NONE; };
+	Const(const std::vector<bool> &bits);
+
 	bool operator <(const RTLIL::Const &other) const;
 	bool operator ==(const RTLIL::Const &other) const;
 	bool operator !=(const RTLIL::Const &other) const;
+
 	bool as_bool() const;
-	int as_int() const;
+	int as_int(bool is_signed = false) const;
 	std::string as_string() const;
+
 	std::string decode_string() const;
+
+	inline int size() const { return bits.size(); }
 };
 
-struct RTLIL::Selection {
+struct RTLIL::Selection
+{
 	bool full_selection;
 	std::set<RTLIL::IdString> selected_modules;
 	std::map<RTLIL::IdString, std::set<RTLIL::IdString>> selected_members;
+
 	Selection(bool full = true) : full_selection(full) { }
+
 	bool selected_module(RTLIL::IdString mod_name) const;
 	bool selected_whole_module(RTLIL::IdString mod_name) const;
 	bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
 	void optimize(RTLIL::Design *design);
+
 	template<typename T1> void select(T1 *module) {
 		if (!full_selection && selected_modules.count(module->name) == 0) {
 			selected_modules.insert(module->name);
 			selected_members.erase(module->name);
 		}
 	}
+
 	template<typename T1, typename T2> void select(T1 *module, T2 *member) {
 		if (!full_selection && selected_modules.count(module->name) == 0)
 			selected_members[module->name].insert(member->name);
 	}
+
 	bool empty() const {
 		return !full_selection && selected_modules.empty() && selected_members.empty();
 	}
 };
 
-struct RTLIL::Design {
-	std::map<RTLIL::IdString, RTLIL::Module*> modules;
+struct RTLIL::Monitor
+{
+	virtual ~Monitor() { }
+	virtual void notify_module_add(RTLIL::Module*) { }
+	virtual void notify_module_del(RTLIL::Module*) { }
+	virtual void notify_connect(RTLIL::Cell*, const RTLIL::IdString&, const RTLIL::SigSpec&, RTLIL::SigSpec&) { }
+	virtual void notify_connect(RTLIL::Module*, const RTLIL::SigSig&) { }
+	virtual void notify_connect(RTLIL::Module*, const std::vector<RTLIL::SigSig>&) { }
+	virtual void notify_blackout(RTLIL::Module*) { }
+};
+
+struct RTLIL::Design
+{
+	std::set<RTLIL::Monitor*> monitors;
+	std::map<std::string, std::string> scratchpad;
+
+	int refcount_modules_;
+	std::map<RTLIL::IdString, RTLIL::Module*> modules_;
+
 	std::vector<RTLIL::Selection> selection_stack;
 	std::map<RTLIL::IdString, RTLIL::Selection> selection_vars;
 	std::string selected_active_module;
+
+	Design();
 	~Design();
+
+	RTLIL::ObjRange<RTLIL::Module*> modules();
+	RTLIL::Module *module(RTLIL::IdString name);
+
+	bool has(RTLIL::IdString id) const {
+		return modules_.count(id) != 0;
+	}
+
+	void add(RTLIL::Module *module);
+	RTLIL::Module *addModule(RTLIL::IdString name);
+	void remove(RTLIL::Module *module);
+
+	void scratchpad_unset(std::string varname);
+
+	void scratchpad_set_int(std::string varname, int value);
+	void scratchpad_set_bool(std::string varname, bool value);
+	void scratchpad_set_string(std::string varname, std::string value);
+
+	int scratchpad_get_int(std::string varname, int default_value = 0) const;
+	bool scratchpad_get_bool(std::string varname, bool default_value = false) const;
+	std::string scratchpad_get_string(std::string varname, std::string default_value = std::string()) const;
+
 	void check();
 	void optimize();
+
 	bool selected_module(RTLIL::IdString mod_name) const;
 	bool selected_whole_module(RTLIL::IdString mod_name) const;
 	bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
+
+	bool selected_module(RTLIL::Module *mod) const;
+	bool selected_whole_module(RTLIL::Module *mod) const;
+
 	bool full_selection() const {
 		return selection_stack.back().full_selection;
 	}
+
 	template<typename T1> bool selected(T1 *module) const {
 		return selected_module(module->name);
 	}
+
 	template<typename T1, typename T2> bool selected(T1 *module, T2 *member) const {
 		return selected_member(module->name, member->name);
 	}
+
 	template<typename T1, typename T2> void select(T1 *module, T2 *member) {
 		if (selection_stack.size() > 0) {
 			RTLIL::Selection &sel = selection_stack.back();
 			sel.select(module, member);
 		}
 	}
+
+	std::vector<RTLIL::Module*> selected_modules() const;
+	std::vector<RTLIL::Module*> selected_whole_modules() const;
+	std::vector<RTLIL::Module*> selected_whole_modules_warn() const;
 };
 
 #define RTLIL_ATTRIBUTE_MEMBERS                                \
@@ -271,159 +566,536 @@ struct RTLIL::Design {
 		return attributes.at(id).as_bool();            \
 	}
 
-struct RTLIL::Module {
+struct RTLIL::Module
+{
+protected:
+	void add(RTLIL::Wire *wire);
+	void add(RTLIL::Cell *cell);
+
+public:
+	RTLIL::Design *design;
+	std::set<RTLIL::Monitor*> monitors;
+
+	int refcount_wires_;
+	int refcount_cells_;
+
+	std::map<RTLIL::IdString, RTLIL::Wire*> wires_;
+	std::map<RTLIL::IdString, RTLIL::Cell*> cells_;
+	std::vector<RTLIL::SigSig> connections_;
+
 	RTLIL::IdString name;
 	std::set<RTLIL::IdString> avail_parameters;
-	std::map<RTLIL::IdString, RTLIL::Wire*> wires;
 	std::map<RTLIL::IdString, RTLIL::Memory*> memories;
-	std::map<RTLIL::IdString, RTLIL::Cell*> cells;
 	std::map<RTLIL::IdString, RTLIL::Process*> processes;
-	std::vector<RTLIL::SigSig> connections;
 	RTLIL_ATTRIBUTE_MEMBERS
+
+	Module();
 	virtual ~Module();
 	virtual RTLIL::IdString derive(RTLIL::Design *design, std::map<RTLIL::IdString, RTLIL::Const> parameters);
 	virtual size_t count_id(RTLIL::IdString id);
 	virtual void check();
 	virtual void optimize();
-	RTLIL::Wire *new_wire(int width, RTLIL::IdString name);
-	void add(RTLIL::Wire *wire);
-	void add(RTLIL::Cell *cell);
+
+	void connect(const RTLIL::SigSig &conn);
+	void connect(const RTLIL::SigSpec &lhs, const RTLIL::SigSpec &rhs);
+	void new_connections(const std::vector<RTLIL::SigSig> &new_conn);
+	const std::vector<RTLIL::SigSig> &connections() const;
+
+	std::vector<RTLIL::IdString> ports;
 	void fixup_ports();
 
 	template<typename T> void rewrite_sigspecs(T functor);
 	void cloneInto(RTLIL::Module *new_mod) const;
 	virtual RTLIL::Module *clone() const;
 
+	bool has_memories() const;
+	bool has_processes() const;
+
+	bool has_memories_warn() const;
+	bool has_processes_warn() const;
+
+	std::vector<RTLIL::Wire*> selected_wires() const;
+	std::vector<RTLIL::Cell*> selected_cells() const;
+
+	template<typename T> bool selected(T *member) const {
+		return design->selected_member(name, member->name);
+	}
+
+	RTLIL::Wire* wire(RTLIL::IdString id) { return wires_.count(id) ? wires_.at(id) : nullptr; }
+	RTLIL::Cell* cell(RTLIL::IdString id) { return cells_.count(id) ? cells_.at(id) : nullptr; }
+
+	RTLIL::ObjRange<RTLIL::Wire*> wires() { return RTLIL::ObjRange<RTLIL::Wire*>(&wires_, &refcount_wires_); }
+	RTLIL::ObjRange<RTLIL::Cell*> cells() { return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); }
+
+	// Removing wires is expensive. If you have to remove wires, remove them all at once.
+	void remove(const std::set<RTLIL::Wire*> &wires);
+	void remove(RTLIL::Cell *cell);
+
+	void rename(RTLIL::Wire *wire, RTLIL::IdString new_name);
+	void rename(RTLIL::Cell *cell, RTLIL::IdString new_name);
+	void rename(RTLIL::IdString old_name, RTLIL::IdString new_name);
+
+	void swap_names(RTLIL::Wire *w1, RTLIL::Wire *w2);
+	void swap_names(RTLIL::Cell *c1, RTLIL::Cell *c2);
+
+	RTLIL::IdString uniquify(RTLIL::IdString name);
+	RTLIL::IdString uniquify(RTLIL::IdString name, int &index);
+
+	RTLIL::Wire *addWire(RTLIL::IdString name, int width = 1);
+	RTLIL::Wire *addWire(RTLIL::IdString name, const RTLIL::Wire *other);
+
+	RTLIL::Cell *addCell(RTLIL::IdString name, RTLIL::IdString type);
+	RTLIL::Cell *addCell(RTLIL::IdString name, const RTLIL::Cell *other);
+
+	// The add* methods create a cell and return the created cell. All signals must exist in advance.
+
+	RTLIL::Cell* addNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addPos (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addNeg (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addShl    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addShr    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addSshl   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addSshr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addShift  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addShiftx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addLt  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addLe  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addEq  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addNe  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addEqx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addNex (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addGe  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addGt  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addAdd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addSub (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addMul (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addDiv (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addMod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	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);
+                     
+	RTLIL::Cell* addLogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addLogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+	RTLIL::Cell* addLogicOr  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
+                     
+	RTLIL::Cell* addMux  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s, RTLIL::SigSpec sig_y);
+	RTLIL::Cell* addPmux (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s, RTLIL::SigSpec sig_y);
+                     
+	RTLIL::Cell* addSlice  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, RTLIL::Const offset);
+	RTLIL::Cell* addConcat (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y);
+	RTLIL::Cell* addLut    (RTLIL::IdString name, RTLIL::SigSpec sig_i, RTLIL::SigSpec sig_o, RTLIL::Const lut);
+	RTLIL::Cell* addAssert (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_en);
+
+	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);
+	RTLIL::Cell* addDff   (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_d,   RTLIL::SigSpec sig_q, bool clk_polarity = true);
+	RTLIL::Cell* addDffsr (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr,
+			RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true);
+	RTLIL::Cell* addAdff (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_arst, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q,
+			RTLIL::Const arst_value, bool clk_polarity = true, bool arst_polarity = true);
+	RTLIL::Cell* addDlatch (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity = true);
+	RTLIL::Cell* addDlatchsr (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr,
+			RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true);
+
+	RTLIL::Cell* addNotGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addAndGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addNandGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addOrGate   (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addNorGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addXorGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addXnorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addMuxGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_s, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addAoi3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_y);
+	RTLIL::Cell* addOai3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_y);
+	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);
+	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);
+
+	RTLIL::Cell* addDffGate    (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity = true);
+	RTLIL::Cell* addDffsrGate  (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr,
+			RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true);
+	RTLIL::Cell* addAdffGate   (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_arst, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q,
+			bool arst_value = false, bool clk_polarity = true, bool arst_polarity = true);
+	RTLIL::Cell* addDlatchGate (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity = true);
+	RTLIL::Cell* addDlatchsrGate  (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr,
+			RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true);
+
+	// The methods without the add* prefix create a cell and an output signal. They return the newly created output signal.
+
+	RTLIL::SigSpec Not (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec Pos (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec Bu0 (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec Neg (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+
+	RTLIL::SigSpec And  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Or   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Xor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Xnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+
+	RTLIL::SigSpec ReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec ReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec ReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec ReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec ReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+
+	RTLIL::SigSpec Shl    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Shr    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Sshl   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Sshr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Shift  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Shiftx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+
+	RTLIL::SigSpec Lt  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Le  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Eq  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Ne  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Eqx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Nex (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Ge  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Gt  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+
+	RTLIL::SigSpec Add (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Sub (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Mul (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Div (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Mod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec Pow (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool a_signed = false, bool b_signed = false);
+
+	RTLIL::SigSpec LogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+	RTLIL::SigSpec LogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+	RTLIL::SigSpec LogicOr  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
+
+	RTLIL::SigSpec Mux      (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s);
+	RTLIL::SigSpec Pmux     (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s);
+
+	RTLIL::SigBit NotGate  (RTLIL::IdString name, RTLIL::SigBit sig_a);
+	RTLIL::SigBit AndGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit NandGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit OrGate   (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit NorGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit XorGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit XnorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b);
+	RTLIL::SigBit MuxGate  (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_s);
+	RTLIL::SigBit Aoi3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c);
+	RTLIL::SigBit Oai3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c);
+	RTLIL::SigBit Aoi4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d);
+	RTLIL::SigBit Oai4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d);
 };
 
-struct RTLIL::Wire {
+struct RTLIL::Wire
+{
+protected:
+	// use module->addWire() and module->remove() to create or destroy wires
+	friend struct RTLIL::Module;
+	Wire();
+	~Wire() { };
+
+public:
+	// do not simply copy wires
+	Wire(RTLIL::Wire &other) = delete;
+	void operator=(RTLIL::Wire &other) = delete;
+
+	RTLIL::Module *module;
 	RTLIL::IdString name;
 	int width, start_offset, port_id;
-	bool port_input, port_output;
+	bool port_input, port_output, upto;
 	RTLIL_ATTRIBUTE_MEMBERS
-	Wire();
 };
 
-struct RTLIL::Memory {
+struct RTLIL::Memory
+{
+	Memory();
+
 	RTLIL::IdString name;
 	int width, start_offset, size;
 	RTLIL_ATTRIBUTE_MEMBERS
-	Memory();
 };
 
-struct RTLIL::Cell {
+struct RTLIL::Cell
+{
+protected:
+	// use module->addCell() and module->remove() to create or destroy cells
+	friend struct RTLIL::Module;
+	Cell();
+
+public:
+	// do not simply copy cells
+	Cell(RTLIL::Cell &other) = delete;
+	void operator=(RTLIL::Cell &other) = delete;
+
+	RTLIL::Module *module;
 	RTLIL::IdString name;
 	RTLIL::IdString type;
-	std::map<RTLIL::IdString, RTLIL::SigSpec> connections;
+	std::map<RTLIL::IdString, RTLIL::SigSpec> connections_;
 	std::map<RTLIL::IdString, RTLIL::Const> parameters;
 	RTLIL_ATTRIBUTE_MEMBERS
-	void optimize();
+
+	// access cell ports
+	bool hasPort(RTLIL::IdString portname) const;
+	void unsetPort(RTLIL::IdString portname);
+	void setPort(RTLIL::IdString portname, RTLIL::SigSpec signal);
+	const RTLIL::SigSpec &getPort(RTLIL::IdString portname) const;
+	const std::map<RTLIL::IdString, RTLIL::SigSpec> &connections() const;
+
+	// access cell parameters
+	bool hasParam(RTLIL::IdString paramname) const;
+	void unsetParam(RTLIL::IdString paramname);
+	void setParam(RTLIL::IdString paramname, RTLIL::Const value);
+	const RTLIL::Const &getParam(RTLIL::IdString paramname) const;
+
+	void check();
+	void fixup_parameters(bool set_a_signed = false, bool set_b_signed = false);
 
 	template<typename T> void rewrite_sigspecs(T functor);
 };
 
-struct RTLIL::SigChunk {
+struct RTLIL::SigChunk
+{
 	RTLIL::Wire *wire;
-	RTLIL::Const data; // only used if wire == NULL, LSB at index 0
+	std::vector<RTLIL::State> data; // only used if wire == NULL, LSB at index 0
 	int width, offset;
+
 	SigChunk();
-	SigChunk(const RTLIL::Const &data);
-	SigChunk(RTLIL::Wire *wire, int width, int offset);
+	SigChunk(const RTLIL::Const &value);
+	SigChunk(RTLIL::Wire *wire);
+	SigChunk(RTLIL::Wire *wire, int offset, int width = 1);
 	SigChunk(const std::string &str);
 	SigChunk(int val, int width = 32);
 	SigChunk(RTLIL::State bit, int width = 1);
 	SigChunk(RTLIL::SigBit bit);
+
 	RTLIL::SigChunk extract(int offset, int length) const;
+
 	bool operator <(const RTLIL::SigChunk &other) const;
 	bool operator ==(const RTLIL::SigChunk &other) const;
 	bool operator !=(const RTLIL::SigChunk &other) const;
-	static bool compare(const RTLIL::SigChunk &a, const RTLIL::SigChunk &b);
 };
 
-struct RTLIL::SigBit {
+struct RTLIL::SigBit
+{
 	RTLIL::Wire *wire;
-	RTLIL::State data;
-	int offset;
-	SigBit() : wire(NULL), data(RTLIL::State::S0), offset(0) { }
-	SigBit(RTLIL::State bit) : wire(NULL), data(bit), offset(0) { }
-	SigBit(RTLIL::Wire *wire) : wire(wire), data(RTLIL::State::S0), offset(0) { assert(!wire || wire->width == 1); }
-	SigBit(RTLIL::Wire *wire, int offset) : wire(wire), data(RTLIL::State::S0), offset(offset) { }
-	SigBit(const RTLIL::SigChunk &chunk) : wire(chunk.wire), data(chunk.wire ? RTLIL::State::S0 : chunk.data.bits[0]), offset(chunk.offset) { assert(chunk.width == 1); }
-	SigBit(const RTLIL::SigChunk &chunk, int index) : wire(chunk.wire), data(chunk.wire ? RTLIL::State::S0 : chunk.data.bits[index]), offset(chunk.wire ? chunk.offset + index : 0) { }
+	union {
+		RTLIL::State data; // used if wire == NULL
+		int offset;        // used if wire != NULL
+	};
+
+	SigBit() : wire(NULL), data(RTLIL::State::S0) { }
+	SigBit(RTLIL::State bit) : wire(NULL), data(bit) { }
+	SigBit(RTLIL::Wire *wire) : wire(wire), offset(0) { log_assert(wire && wire->width == 1); }
+	SigBit(RTLIL::Wire *wire, int offset) : wire(wire), offset(offset) { log_assert(wire); }
+	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) : wire(chunk.wire) { if (wire) offset = chunk.offset + index; else data = chunk.data[index]; }
 	SigBit(const RTLIL::SigSpec &sig);
+
 	bool operator <(const RTLIL::SigBit &other) const {
-		return (wire != other.wire) ? (wire < other.wire) : wire ? (offset < other.offset) : (data < other.data);
+		if (wire == other.wire)
+			return wire ? (offset < other.offset) : (data < other.data);
+		if (wire != nullptr && other.wire != nullptr)
+			return wire->name < other.wire->name;
+		return wire < other.wire;
 	}
+
 	bool operator ==(const RTLIL::SigBit &other) const {
 		return (wire == other.wire) && (wire ? (offset == other.offset) : (data == other.data));
 	}
+
 	bool operator !=(const RTLIL::SigBit &other) const {
 		return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
 	}
 };
 
-struct RTLIL::SigSpec {
-	std::vector<RTLIL::SigChunk> chunks; // LSB at index 0
-	int width;
+struct RTLIL::SigSpecIterator
+{
+	RTLIL::SigSpec *sig_p;
+	int index;
+
+	inline RTLIL::SigBit &operator*() const;
+	inline bool operator!=(const RTLIL::SigSpecIterator &other) const { return index != other.index; }
+	inline void operator++() { index++; }
+};
+
+struct RTLIL::SigSpecConstIterator
+{
+	const RTLIL::SigSpec *sig_p;
+	int index;
+
+	inline const RTLIL::SigBit &operator*() const;
+	inline bool operator!=(const RTLIL::SigSpecConstIterator &other) const { return index != other.index; }
+	inline void operator++() { index++; }
+};
+
+struct RTLIL::SigSpec
+{
+private:
+	int width_;
+	unsigned long hash_;
+	std::vector<RTLIL::SigChunk> chunks_; // LSB at index 0
+	std::vector<RTLIL::SigBit> bits_; // LSB at index 0
+
+	void pack() const;
+	void unpack() const;
+	void hash() const;
+
+	inline bool packed() const {
+		return bits_.empty();
+	}
+
+	inline void inline_unpack() const {
+		if (!chunks_.empty())
+			unpack();
+	}
+
+public:
 	SigSpec();
-	SigSpec(const RTLIL::Const &data);
+	SigSpec(const RTLIL::SigSpec &other);
+	SigSpec(std::initializer_list<RTLIL::SigSpec> parts);
+	const RTLIL::SigSpec &operator=(const RTLIL::SigSpec &other);
+
+	SigSpec(const RTLIL::Const &value);
 	SigSpec(const RTLIL::SigChunk &chunk);
-	SigSpec(RTLIL::Wire *wire, int width = -1, int offset = 0);
+	SigSpec(RTLIL::Wire *wire);
+	SigSpec(RTLIL::Wire *wire, int offset, int width = 1);
 	SigSpec(const std::string &str);
 	SigSpec(int val, int width = 32);
 	SigSpec(RTLIL::State bit, int width = 1);
 	SigSpec(RTLIL::SigBit bit, int width = 1);
+	SigSpec(std::vector<RTLIL::SigChunk> chunks);
 	SigSpec(std::vector<RTLIL::SigBit> bits);
-	void expand();
-	void optimize();
-	RTLIL::SigSpec optimized() const;
+	SigSpec(std::set<RTLIL::SigBit> bits);
+
+	SigSpec(RTLIL::SigSpec &&other) {
+		width_ = other.width_;
+		hash_ = other.hash_;
+		chunks_ = std::move(other.chunks_);
+		bits_ = std::move(other.bits_);
+	}
+
+	const RTLIL::SigSpec &operator=(RTLIL::SigSpec &&other) {
+		width_ = other.width_;
+		hash_ = other.hash_;
+		chunks_ = std::move(other.chunks_);
+		bits_ = std::move(other.bits_);
+		return *this;
+	}
+
+	inline const std::vector<RTLIL::SigChunk> &chunks() const { pack(); return chunks_; }
+	inline const std::vector<RTLIL::SigBit> &bits() const { inline_unpack(); return bits_; }
+
+	inline int size() const { return width_; }
+
+	inline RTLIL::SigBit &operator[](int index) { inline_unpack(); return bits_.at(index); }
+	inline const RTLIL::SigBit &operator[](int index) const { inline_unpack(); return bits_.at(index); }
+
+	inline RTLIL::SigSpecIterator begin() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = 0; return it; }
+	inline RTLIL::SigSpecIterator end() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = width_; return it; }
+
+	inline RTLIL::SigSpecConstIterator begin() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = 0; return it; }
+	inline RTLIL::SigSpecConstIterator end() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = width_; return it; }
+
 	void sort();
 	void sort_and_unify();
+
 	void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with);
 	void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with, RTLIL::SigSpec *other) const;
+
+	void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules);
+	void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
+
+	void replace(int offset, const RTLIL::SigSpec &with);
+
 	void remove(const RTLIL::SigSpec &pattern);
 	void remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) const;
 	void remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other);
-	RTLIL::SigSpec extract(RTLIL::SigSpec pattern, RTLIL::SigSpec *other = NULL) const;
-	void replace(int offset, const RTLIL::SigSpec &with);
+
+	void remove(const std::set<RTLIL::SigBit> &pattern);
+	void remove(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const;
+	void remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
+
+	void remove(int offset, int length = 1);
 	void remove_const();
-	void remove(int offset, int length);
-	RTLIL::SigSpec extract(int offset, int length) const;
+
+	RTLIL::SigSpec extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other = NULL) const;
+	RTLIL::SigSpec extract(const std::set<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other = NULL) const;
+	RTLIL::SigSpec extract(int offset, int length = 1) const;
+
 	void append(const RTLIL::SigSpec &signal);
 	void append_bit(const RTLIL::SigBit &bit);
-	bool combine(RTLIL::SigSpec signal, RTLIL::State freeState = RTLIL::State::Sz, bool override = false);
+
 	void extend(int width, bool is_signed = false);
 	void extend_u0(int width, bool is_signed = false);
-	void check() const;
+
+	RTLIL::SigSpec repeat(int num) const;
+
 	bool operator <(const RTLIL::SigSpec &other) const;
 	bool operator ==(const RTLIL::SigSpec &other) const;
-	bool operator !=(const RTLIL::SigSpec &other) const;
+	inline bool operator !=(const RTLIL::SigSpec &other) const { return !(*this == other); }
+
+	bool is_wire() const;
+	bool is_chunk() const;
+
 	bool is_fully_const() const;
 	bool is_fully_def() const;
 	bool is_fully_undef() const;
 	bool has_marked_bits() const;
+
 	bool as_bool() const;
-	int as_int() const;
+	int as_int(bool is_signed = false) const;
 	std::string as_string() const;
 	RTLIL::Const as_const() const;
+	RTLIL::Wire *as_wire() const;
+	RTLIL::SigChunk as_chunk() const;
+
 	bool match(std::string pattern) const;
+
 	std::set<RTLIL::SigBit> to_sigbit_set() const;
 	std::vector<RTLIL::SigBit> to_sigbit_vector() const;
+	std::map<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_map(const RTLIL::SigSpec &other) const;
 	RTLIL::SigBit to_single_sigbit() const;
+
 	static bool parse(RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
 	static bool parse_sel(RTLIL::SigSpec &sig, RTLIL::Design *design, RTLIL::Module *module, std::string str);
 	static bool parse_rhs(const RTLIL::SigSpec &lhs, RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
+
+	operator std::vector<RTLIL::SigChunk>() const { return chunks(); }
+	operator std::vector<RTLIL::SigBit>() const { return bits(); }
+
+#ifndef NDEBUG
+	void check() const;
+#else
+	inline void check() const { }
+#endif
 };
 
+inline RTLIL::SigBit &RTLIL::SigSpecIterator::operator*() const {
+	return (*sig_p)[index];
+}
+
+inline const RTLIL::SigBit &RTLIL::SigSpecConstIterator::operator*() const {
+	return (*sig_p)[index];
+}
+
 inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec &sig) {
-	assert(sig.width == 1 && sig.chunks.size() == 1);
-	*this = SigBit(sig.chunks[0]);
+	log_assert(sig.size() == 1 && sig.chunks().size() == 1);
+	*this = SigBit(sig.chunks().front());
 }
 
-struct RTLIL::CaseRule {
+struct RTLIL::CaseRule
+{
 	std::vector<RTLIL::SigSpec> compare;
 	std::vector<RTLIL::SigSig> actions;
 	std::vector<RTLIL::SwitchRule*> switches;
+
 	~CaseRule();
 	void optimize();
 
@@ -431,34 +1103,36 @@ struct RTLIL::CaseRule {
 	RTLIL::CaseRule *clone() const;
 };
 
-struct RTLIL::SwitchRule {
+struct RTLIL::SwitchRule
+{
 	RTLIL::SigSpec signal;
 	RTLIL_ATTRIBUTE_MEMBERS
 	std::vector<RTLIL::CaseRule*> cases;
+
 	~SwitchRule();
-	void optimize();
 
 	template<typename T> void rewrite_sigspecs(T functor);
 	RTLIL::SwitchRule *clone() const;
 };
 
-struct RTLIL::SyncRule {
+struct RTLIL::SyncRule
+{
 	RTLIL::SyncType type;
 	RTLIL::SigSpec signal;
 	std::vector<RTLIL::SigSig> actions;
-	void optimize();
 
 	template<typename T> void rewrite_sigspecs(T functor);
 	RTLIL::SyncRule *clone() const;
 };
 
-struct RTLIL::Process {
+struct RTLIL::Process
+{
 	RTLIL::IdString name;
 	RTLIL_ATTRIBUTE_MEMBERS
 	RTLIL::CaseRule root_case;
 	std::vector<RTLIL::SyncRule*> syncs;
+
 	~Process();
-	void optimize();
 
 	template<typename T> void rewrite_sigspecs(T functor);
 	RTLIL::Process *clone() const;
@@ -467,11 +1141,11 @@ struct RTLIL::Process {
 template<typename T>
 void RTLIL::Module::rewrite_sigspecs(T functor)
 {
-	for (auto &it : cells)
+	for (auto &it : cells_)
 		it.second->rewrite_sigspecs(functor);
 	for (auto &it : processes)
 		it.second->rewrite_sigspecs(functor);
-	for (auto &it : connections) {
+	for (auto &it : connections_) {
 		functor(it.first);
 		functor(it.second);
 	}
@@ -479,7 +1153,7 @@ void RTLIL::Module::rewrite_sigspecs(T functor)
 
 template<typename T>
 void RTLIL::Cell::rewrite_sigspecs(T functor) {
-	for (auto &it : connections)
+	for (auto &it : connections_)
 		functor(it.second);
 }
 
@@ -521,4 +1195,6 @@ void RTLIL::Process::rewrite_sigspecs(T functor)
 		it->rewrite_sigspecs(functor);
 }
 
+YOSYS_NAMESPACE_END
+
 #endif