yowasp-yosys 0.59.0.0.post1038__py3-none-any.whl → 0.60.0.0.post1055__py3-none-any.whl

yowasp_yosys/share/include/kernel/constids.inc

@@ -196,6 +196,7 @@ X($bweqx)
 X($bwmux)
 X($check)
 X($concat)
+X($connect)
 X($cover)
 X($demux)
 X($dff)
@@ -222,6 +223,7 @@ X($get_tag)
 X($gt)
 X($initstate)
 X($input)
+X($input_port)
 X($lcu)
 X($le)
 X($live)

yowasp_yosys/share/include/kernel/ff.h

@@ -78,31 +78,20 @@ YOSYS_NAMESPACE_BEGIN
 // - has_arst [does not correspond to a native cell, represented as dlatch with const D input]
 // - empty set [not a cell — will be emitted as a simple direct connection]
 
-struct FfData {
-	Module *module;
-	FfInitVals *initvals;
-	Cell *cell;
-	IdString name;
-	// The FF output.
-	SigSpec sig_q;
-	// The sync data input, present if has_clk or has_gclk.
-	SigSpec sig_d;
-	// The async data input, present if has_aload.
-	SigSpec sig_ad;
-	// The sync clock, present if has_clk.
-	SigSpec sig_clk;
-	// The clock enable, present if has_ce.
-	SigSpec sig_ce;
-	// The async load enable, present if has_aload.
-	SigSpec sig_aload;
-	// The async reset, preset if has_arst.
-	SigSpec sig_arst;
-	// The sync reset, preset if has_srst.
-	SigSpec sig_srst;
-	// The async clear (per-lane), present if has_sr.
-	SigSpec sig_clr;
-	// The async set (per-lane), present if has_sr.
-	SigSpec sig_set;
+struct FfTypeData {
+	FfTypeData(IdString type);
+	FfTypeData() {
+		has_clk = false;
+		has_gclk = false;
+		has_ce = false;
+		has_aload = false;
+		has_srst = false;
+		has_arst = false;
+		has_sr = false;
+		ce_over_srst = false;
+		is_fine = false;
+		is_anyinit = false;
+	}
 	// True if this is a clocked (edge-sensitive) flip-flop.
 	bool has_clk;
 	// True if this is a $ff, exclusive with every other has_*.
@@ -143,9 +132,38 @@ struct FfData {
 	bool pol_clr;
 	bool pol_set;
 	// The value loaded by sig_arst.
+	// Zero length if unknowable from just type
 	Const val_arst;
 	// The value loaded by sig_srst.
+	// Zero length if unknowable from just type
 	Const val_srst;
+};
+
+struct FfData : FfTypeData {
+	Module *module;
+	FfInitVals *initvals;
+	Cell *cell;
+	IdString name;
+	// The FF output.
+	SigSpec sig_q;
+	// The sync data input, present if has_clk or has_gclk.
+	SigSpec sig_d;
+	// The async data input, present if has_aload.
+	SigSpec sig_ad;
+	// The sync clock, present if has_clk.
+	SigSpec sig_clk;
+	// The clock enable, present if has_ce.
+	SigSpec sig_ce;
+	// The async load enable, present if has_aload.
+	SigSpec sig_aload;
+	// The async reset, preset if has_arst.
+	SigSpec sig_arst;
+	// The sync reset, preset if has_srst.
+	SigSpec sig_srst;
+	// The async clear (per-lane), present if has_sr.
+	SigSpec sig_clr;
+	// The async set (per-lane), present if has_sr.
+	SigSpec sig_set;
 	// The initial value at power-up.
 	Const val_init;
 	// The FF data width in bits.
@@ -154,16 +172,6 @@ struct FfData {
 
 	FfData(Module *module = nullptr, FfInitVals *initvals = nullptr, IdString name = IdString()) : module(module), initvals(initvals), cell(nullptr), name(name) {
 		width = 0;
-		has_clk = false;
-		has_gclk = false;
-		has_ce = false;
-		has_aload = false;
-		has_srst = false;
-		has_arst = false;
-		has_sr = false;
-		ce_over_srst = false;
-		is_fine = false;
-		is_anyinit = false;
 		pol_clk = false;
 		pol_aload = false;
 		pol_ce = false;

yowasp_yosys/share/include/kernel/log.h

@@ -24,6 +24,7 @@
 
 #include <time.h>
 
+#include <atomic>
 #include <regex>
 #define YS_REGEX_COMPILE(param) std::regex(param, \
 				std::regex_constants::nosubs | \
@@ -298,15 +299,16 @@ void log_abort_internal(const char *file, int line);
 
 #define cover(_id) do { \
     static CoverData __d __attribute__((section("yosys_cover_list"), aligned(1), used)) = { __FILE__, __FUNCTION__, _id, __LINE__, 0 }; \
-    __d.counter++; \
+    __d.counter.fetch_add(1, std::memory_order_relaxed); \
 } while (0)
 
 struct CoverData {
 	const char *file, *func, *id;
-	int line, counter;
-} YS_ATTRIBUTE(packed);
+	int line;
+	std::atomic<int> counter;
+};
 
-// this two symbols are created by the linker for the "yosys_cover_list" ELF section
+// this two symbols are created by the linker __start_yosys_cover_listfor the "yosys_cover_list" ELF section
 extern "C" struct CoverData __start_yosys_cover_list[];
 extern "C" struct CoverData __stop_yosys_cover_list[];
 

yowasp_yosys/share/include/kernel/register.h

@@ -50,6 +50,30 @@ struct source_location { // dummy placeholder
 
 YOSYS_NAMESPACE_BEGIN
 
+// Track whether garbage collection is enabled. Garbage collection must be disabled
+// while any RTLIL objects (e.g. non-owning non-immortal IdStrings) exist outside Designs.
+// Garbage collection is disabled whenever any GarbageCollectionGuard(false) is on the
+// stack. These objects must be stack-allocated on the main thread.
+class GarbageCollectionGuard
+{
+	bool was_enabled;
+	static bool is_enabled_;
+public:
+	GarbageCollectionGuard(bool allow) : was_enabled(is_enabled_) {
+		is_enabled_ &= allow;
+	}
+	~GarbageCollectionGuard() {
+		is_enabled_ = was_enabled;
+	}
+	static bool is_enabled() { return is_enabled_; }
+};
+
+// Call from anywhere to request GC at the next safe point.
+void request_garbage_collection();
+
+// GC if GarbageCollectionGuard::is_enabled() and GC was requested.
+void try_collect_garbage();
+
 struct Pass
 {
 	std::string pass_name, short_help;
@@ -71,6 +95,8 @@ struct Pass
 	bool experimental_flag = false;
 	bool internal_flag = false;
 
+	static void subtract_from_current_runtime_ns(int64_t time_ns);
+
 	void experimental() {
 		experimental_flag = true;
 	}
@@ -108,6 +134,10 @@ struct Pass
 	virtual void on_register();
 	virtual void on_shutdown();
 	virtual bool replace_existing_pass() const { return false; }
+
+	// This should return false if the pass holds onto RTLIL objects outside a Design while it
+	// calls nested passes. For safety, we default to assuming the worst.
+	virtual bool allow_garbage_collection_during_pass() const { return false; }
 };
 
 struct ScriptPass : Pass
@@ -126,6 +156,8 @@ struct ScriptPass : Pass
 	void run_nocheck(std::string command, std::string info = std::string());
 	void run_script(RTLIL::Design *design, std::string run_from = std::string(), std::string run_to = std::string());
 	void help_script();
+
+	bool allow_garbage_collection_during_pass() const override { return true; }
 };
 
 struct Frontend : Pass

yowasp_yosys/share/include/kernel/rtlil.h

@@ -53,10 +53,11 @@ namespace RTLIL
 	// Semantic metadata - how can this constant be interpreted?
 	// Values may be generally non-exclusive
 	enum ConstFlags : unsigned char {
-		CONST_FLAG_NONE   = 0,
-		CONST_FLAG_STRING = 1,
-		CONST_FLAG_SIGNED = 2,  // only used for parameters
-		CONST_FLAG_REAL   = 4   // only used for parameters
+		CONST_FLAG_NONE    = 0,
+		CONST_FLAG_STRING  = 1,
+		CONST_FLAG_SIGNED  = 2,  // only used for parameters
+		CONST_FLAG_REAL    = 4,  // only used for parameters
+		CONST_FLAG_UNSIZED = 8,  // only used for parameters
 	};
 
 	enum SelectPartials : unsigned char {
@@ -120,27 +121,30 @@ namespace RTLIL
 	struct Process;
 	struct Binding;
 	struct IdString;
-	struct StaticIdString;
+	struct OwningIdString;
 
 	typedef std::pair<SigSpec, SigSpec> SigSig;
-
-	struct StaticIdString {
-		constexpr StaticIdString(StaticId id, const IdString &id_str) : id_str(id_str), id(id) {}
-		constexpr inline operator const IdString &() const { return id_str; }
-		constexpr inline int index() const { return static_cast<short>(id); }
-		constexpr inline const IdString &id_string() const { return id_str; }
-
-		const IdString &id_str;
-		const StaticId id;
-	};
 };
 
 struct RTLIL::IdString
 {
-	#undef YOSYS_XTRACE_GET_PUT
-	#undef YOSYS_SORT_ID_FREE_LIST
-	#undef YOSYS_USE_STICKY_IDS
-	#undef YOSYS_NO_IDS_REFCNT
+	struct Storage {
+		char *buf;
+		int size;
+
+		std::string_view str_view() const { return {buf, static_cast<size_t>(size)}; }
+	};
+	struct AutoidxStorage {
+		// Append the negated (i.e. positive) ID to this string to get
+		// the real string. The prefix strings must live forever.
+		const std::string *prefix;
+		// Cache of the full string, or nullptr if not cached yet.
+		std::atomic<char *> full_str;
+
+		AutoidxStorage(const std::string *prefix) : prefix(prefix), full_str(nullptr) {}
+		AutoidxStorage(AutoidxStorage&& other) : prefix(other.prefix), full_str(other.full_str.exchange(nullptr, std::memory_order_relaxed)) {}
+		~AutoidxStorage() { delete[] full_str.load(std::memory_order_acquire); }
+	};
 
 	// the global id string cache
 
@@ -150,200 +154,82 @@ struct RTLIL::IdString
 		~destruct_guard_t() { destruct_guard_ok = false; }
 	} destruct_guard;
 
-	static std::vector<char*> global_id_storage_;
+	// String storage for non-autoidx IDs
+	static std::vector<Storage> global_id_storage_;
+	// Lookup table for non-autoidx IDs
 	static std::unordered_map<std::string_view, int> global_id_index_;
-#ifndef YOSYS_NO_IDS_REFCNT
-	// For prepopulated IdStrings, the refcount is meaningless since they
-	// are never freed even if the refcount is zero. For code efficiency
-	// we increment the refcount of prepopulated IdStrings like any other string,
-	// but we never decrement the refcount or check whether it's zero.
-	// So, make this unsigned because refcounts of preopulated IdStrings may overflow
-	// and overflow of signed integers is undefined behavior.
-	static std::vector<uint32_t> global_refcount_storage_;
+	// Storage for autoidx IDs, which have negative indices, i.e. all entries in this
+	// map have negative keys.
+	static std::unordered_map<int, AutoidxStorage> global_autoidx_id_storage_;
+	// All (index, refcount) pairs in this map have refcount > 0.
+	static std::unordered_map<int, int> global_refcount_storage_;
 	static std::vector<int> global_free_idx_list_;
-#endif
 
-#ifdef YOSYS_USE_STICKY_IDS
-	static int last_created_idx_ptr_;
-	static int last_created_idx_[8];
-#endif
+	static int refcount(int idx) {
+		auto it = global_refcount_storage_.find(idx);
+		if (it == global_refcount_storage_.end())
+			return 0;
+		return it->second;
+	}
 
 	static inline void xtrace_db_dump()
 	{
 	#ifdef YOSYS_XTRACE_GET_PUT
 		for (int idx = 0; idx < GetSize(global_id_storage_); idx++)
 		{
-			if (global_id_storage_.at(idx) == nullptr)
+			if (global_id_storage_.at(idx).buf == nullptr)
 				log("#X# DB-DUMP index %d: FREE\n", idx);
 			else
-				log("#X# DB-DUMP index %d: '%s' (ref %u)\n", idx, global_id_storage_.at(idx), global_refcount_storage_.at(idx));
+				log("#X# DB-DUMP index %d: '%s' (ref %u)\n", idx, global_id_storage_.at(idx).buf, refcount(idx));
 		}
 	#endif
 	}
 
 	static inline void checkpoint()
 	{
-	#ifdef YOSYS_USE_STICKY_IDS
-		last_created_idx_ptr_ = 0;
-		for (int i = 0; i < 8; i++) {
-			if (last_created_idx_[i])
-				put_reference(last_created_idx_[i]);
-			last_created_idx_[i] = 0;
-		}
-	#endif
 	#ifdef YOSYS_SORT_ID_FREE_LIST
 		std::sort(global_free_idx_list_.begin(), global_free_idx_list_.end(), std::greater<int>());
 	#endif
 	}
 
-	static inline int get_reference(int idx)
-	{
-	#ifndef YOSYS_NO_IDS_REFCNT
-		global_refcount_storage_[idx]++;
-	#endif
-	#ifdef YOSYS_XTRACE_GET_PUT
-		if (yosys_xtrace && idx >= static_cast<short>(StaticId::STATIC_ID_END))
-			log("#X# GET-BY-INDEX '%s' (index %d, refcount %u)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
-	#endif
-		return idx;
-	}
-
-	static int get_reference(const char *p)
-	{
-		return get_reference(std::string_view(p));
-	}
-
-	static int get_reference(std::string_view p)
+	static int insert(std::string_view p)
 	{
 		log_assert(destruct_guard_ok);
+		log_assert(!Multithreading::active());
 
 		auto it = global_id_index_.find(p);
 		if (it != global_id_index_.end()) {
-	#ifndef YOSYS_NO_IDS_REFCNT
-			global_refcount_storage_.at(it->second)++;
-	#endif
 	#ifdef YOSYS_XTRACE_GET_PUT
 			if (yosys_xtrace)
-				log("#X# GET-BY-NAME '%s' (index %d, refcount %u)\n", global_id_storage_.at(it->second), it->second, global_refcount_storage_.at(it->second));
+				log("#X# GET-BY-NAME '%s' (index %d, refcount %u)\n", global_id_storage_.at(it->second).buf, it->second, refcount(it->second));
 	#endif
 			return it->second;
 		}
-
-		ensure_prepopulated();
-
-		if (p.empty())
-			return 0;
-
-		log_assert(p[0] == '$' || p[0] == '\\');
-		for (char ch : p)
-			if ((unsigned)ch <= (unsigned)' ')
-				log_error("Found control character or space (0x%02x) in string '%s' which is not allowed in RTLIL identifiers\n", ch, std::string(p).c_str());
-
-	#ifndef YOSYS_NO_IDS_REFCNT
-		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();
-		char* buf = static_cast<char*>(malloc(p.size() + 1));
-		memcpy(buf, p.data(), p.size());
-		buf[p.size()] = 0;
-		global_id_storage_.at(idx) = buf;
-		global_id_index_.insert(it, {std::string_view(buf, p.size()), idx});
-		global_refcount_storage_.at(idx)++;
-	#else
-		int idx = global_id_storage_.size();
-		global_id_storage_.push_back(strdup(p));
-		global_id_index_[global_id_storage_.back()] = idx;
-	#endif
-
-		if (yosys_xtrace) {
-			log("#X# New IdString '%s' with index %d.\n", global_id_storage_.at(idx), idx);
-			log_backtrace("-X- ", yosys_xtrace-1);
-		}
-
-	#ifdef YOSYS_XTRACE_GET_PUT
-		if (yosys_xtrace)
-			log("#X# GET-BY-NAME '%s' (index %d, refcount %u)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
-	#endif
-
-	#ifdef YOSYS_USE_STICKY_IDS
-		// Avoid Create->Delete->Create pattern
-		if (last_created_idx_[last_created_idx_ptr_])
-			put_reference(last_created_idx_[last_created_idx_ptr_]);
-		last_created_idx_[last_created_idx_ptr_] = idx;
-		get_reference(last_created_idx_[last_created_idx_ptr_]);
-		last_created_idx_ptr_ = (last_created_idx_ptr_ + 1) & 7;
-	#endif
-
-		return idx;
+		return really_insert(p, it);
 	}
 
-#ifndef YOSYS_NO_IDS_REFCNT
-	static inline void put_reference(int idx)
-	{
-		// put_reference() may be called from destructors after the destructor of
-		// global_refcount_storage_ has been run. in this case we simply do nothing.
-		if (idx < static_cast<short>(StaticId::STATIC_ID_END) || !destruct_guard_ok)
-			return;
-
-	#ifdef YOSYS_XTRACE_GET_PUT
-		if (yosys_xtrace) {
-			log("#X# PUT '%s' (index %d, refcount %u)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
-		}
-	#endif
-
-		uint32_t &refcount = global_refcount_storage_[idx];
-
-		if (--refcount > 0)
-			return;
-
-		free_reference(idx);
-	}
-	static inline void free_reference(int idx)
-	{
-		if (yosys_xtrace) {
-			log("#X# Removed IdString '%s' with index %d.\n", global_id_storage_.at(idx), idx);
-			log_backtrace("-X- ", yosys_xtrace-1);
-		}
-		log_assert(idx >= static_cast<short>(StaticId::STATIC_ID_END));
-
-		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);
+	// Inserts an ID with string `prefix + autoidx', incrementing autoidx.
+	// `prefix` must start with '$auto$', end with '$', and live forever.
+	static IdString new_autoidx_with_prefix(const std::string *prefix) {
+		log_assert(!Multithreading::active());
+		int index = -(autoidx++);
+		global_autoidx_id_storage_.insert({index, prefix});
+		return from_index(index);
 	}
-#else
-	static inline void put_reference(int) { }
-#endif
 
 	// the actual IdString object is just is a single int
 
 	int index_;
 
-	inline IdString() : index_(0) { }
-	inline IdString(const char *str) : index_(get_reference(str)) { }
-	inline IdString(const IdString &str) : index_(get_reference(str.index_)) { }
+	constexpr inline IdString() : index_(0) { }
+	inline IdString(const char *str) : index_(insert(std::string_view(str))) { }
+	constexpr inline IdString(const IdString &str) : index_(str.index_) { }
 	inline IdString(IdString &&str) : index_(str.index_) { str.index_ = 0; }
-	inline IdString(const std::string &str) : index_(get_reference(std::string_view(str))) { }
-	inline IdString(std::string_view str) : index_(get_reference(str)) { }
-	inline IdString(StaticId id) : index_(static_cast<short>(id)) {}
-	inline ~IdString() { put_reference(index_); }
-
-	inline void operator=(const IdString &rhs) {
-		put_reference(index_);
-		index_ = get_reference(rhs.index_);
-	}
+	inline IdString(const std::string &str) : index_(insert(std::string_view(str))) { }
+	inline IdString(std::string_view str) : index_(insert(str)) { }
+	constexpr inline IdString(StaticId id) : index_(static_cast<short>(id)) {}
 
-	inline void operator=(IdString &&rhs) {
-		put_reference(index_);
-		index_ = rhs.index_;
-		rhs.index_ = 0;
-	}
+	IdString &operator=(const IdString &rhs) = default;
 
 	inline void operator=(const char *rhs) {
 		IdString id(rhs);
@@ -358,11 +244,159 @@ struct RTLIL::IdString
 	constexpr inline const IdString &id_string() const { return *this; }
 
 	inline const char *c_str() const {
-		return global_id_storage_.at(index_);
+		if (index_ >= 0)
+			return global_id_storage_.at(index_).buf;
+
+		AutoidxStorage &s = global_autoidx_id_storage_.at(index_);
+		char *full_str = s.full_str.load(std::memory_order_acquire);
+		if (full_str != nullptr)
+			return full_str;
+		const std::string &prefix = *s.prefix;
+		std::string suffix = std::to_string(-index_);
+		char *c = new char[prefix.size() + suffix.size() + 1];
+		memcpy(c, prefix.data(), prefix.size());
+		memcpy(c + prefix.size(), suffix.c_str(), suffix.size() + 1);
+		if (s.full_str.compare_exchange_strong(full_str, c, std::memory_order_acq_rel))
+			return c;
+		delete[] c;
+		return full_str;
 	}
 
 	inline std::string str() const {
-		return std::string(global_id_storage_.at(index_));
+		std::string result;
+		append_to(&result);
+		return result;
+	}
+
+	inline void append_to(std::string *out) const {
+		if (index_ >= 0) {
+			*out += global_id_storage_.at(index_).str_view();
+			return;
+		}
+		*out += *global_autoidx_id_storage_.at(index_).prefix;
+		*out += std::to_string(-index_);
+	}
+
+	class Substrings {
+		std::string_view first_;
+		int suffix_number;
+		char buf[10];
+	public:
+		Substrings(const Storage &storage) : first_(storage.str_view()), suffix_number(-1) {}
+		// suffix_number must be non-negative
+		Substrings(const std::string *prefix, int suffix_number)
+				: first_(*prefix), suffix_number(suffix_number) {}
+		std::string_view first() { return first_; }
+		std::optional<std::string_view> next() {
+			if (suffix_number < 0)
+				return std::nullopt;
+                       int i = sizeof(buf);
+			do {
+				--i;
+                               buf[i] = (suffix_number % 10) + '0';
+                               suffix_number /= 10;
+			} while (suffix_number > 0);
+			suffix_number = -1;
+			return std::string_view(buf + i, sizeof(buf) - i);
+		}
+	};
+
+	class const_iterator {
+		const std::string *prefix;
+		std::string suffix;
+		const char *c_str;
+		int c_str_len;
+		// When this is INT_MAX it's the generic "end" value.
+		int index;
+
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type = char;
+		using difference_type = std::ptrdiff_t;
+		using pointer = const char*;
+		using reference = const char&;
+
+		const_iterator(const Storage &storage) : prefix(nullptr), c_str(storage.buf), c_str_len(storage.size), index(0) {}
+		const_iterator(const std::string *prefix, int number) :
+				prefix(prefix), suffix(std::to_string(number)), c_str(nullptr), c_str_len(0), index(0) {}
+		// Construct end-marker
+		const_iterator() : prefix(nullptr), c_str(nullptr), c_str_len(0), index(INT_MAX) {}
+
+		int size() const {
+			if (c_str != nullptr)
+				return c_str_len;
+			return GetSize(*prefix) + GetSize(suffix);
+		}
+
+		char operator*() const {
+			if (c_str != nullptr)
+				return c_str[index];
+			int prefix_size = GetSize(*prefix);
+			if (index < prefix_size)
+				return prefix->at(index);
+			return suffix[index - prefix_size];
+		}
+
+		const_iterator& operator++() { ++index; return *this; }
+		const_iterator operator++(int) { const_iterator result(*this); ++index; return result; }
+		const_iterator& operator+=(int i) { index += i; return *this; }
+
+		const_iterator operator+(int add) {
+			const_iterator result = *this;
+			result += add;
+			return result;
+		}
+
+		bool operator==(const const_iterator& other) const {
+			return index == other.index || (other.index == INT_MAX && index == size())
+				|| (index == INT_MAX && other.index == other.size());
+		}
+		bool operator!=(const const_iterator& other) const {
+			return !(*this == other);
+		}
+	};
+	const_iterator begin() const {
+		if (index_ >= 0) {
+			return const_iterator(global_id_storage_.at(index_));
+		}
+		return const_iterator(global_autoidx_id_storage_.at(index_).prefix, -index_);
+	}
+	const_iterator end() const {
+		return const_iterator();
+	}
+
+	Substrings substrings() const {
+		if (index_ >= 0) {
+			return Substrings(global_id_storage_.at(index_));
+		}
+		return Substrings(global_autoidx_id_storage_.at(index_).prefix, -index_);
+	}
+
+	inline bool lt_by_name(const IdString &rhs) const {
+		Substrings lhs_it = substrings();
+		Substrings rhs_it = rhs.substrings();
+		std::string_view lhs_substr = lhs_it.first();
+		std::string_view rhs_substr = rhs_it.first();
+		while (true) {
+			int min = std::min(GetSize(lhs_substr), GetSize(rhs_substr));
+			int diff = memcmp(lhs_substr.data(), rhs_substr.data(), min);
+			if (diff != 0)
+				return diff < 0;
+			lhs_substr = lhs_substr.substr(min);
+			rhs_substr = rhs_substr.substr(min);
+			if (rhs_substr.empty()) {
+				if (std::optional<std::string_view> s = rhs_it.next())
+					rhs_substr = *s;
+				else
+					return false;
+			}
+			if (lhs_substr.empty()) {
+				if (std::optional<std::string_view> s = lhs_it.next())
+					lhs_substr = *s;
+				else
+					return true;
+			}
+		}
 	}
 
 	inline bool operator<(const IdString &rhs) const {
@@ -371,8 +405,6 @@ struct RTLIL::IdString
 
 	inline bool operator==(const IdString &rhs) const { return index_ == rhs.index_; }
 	inline bool operator!=(const IdString &rhs) const { return index_ != rhs.index_; }
-	inline bool operator==(const StaticIdString &rhs) const;
-	inline bool operator!=(const StaticIdString &rhs) const;
 
 	// The methods below are just convenience functions for better compatibility with std::string.
 
@@ -383,45 +415,84 @@ struct RTLIL::IdString
 	bool operator!=(const char *rhs) const { return strcmp(c_str(), rhs) != 0; }
 
 	char operator[](size_t i) const {
-					const char *p = c_str();
+		if (index_ >= 0) {
+			const Storage &storage = global_id_storage_.at(index_);
 #ifndef NDEBUG
-		for (; i != 0; i--, p++)
-			log_assert(*p != 0);
-		return *p;
-#else
-		return *(p + i);
+			log_assert(static_cast<int>(i) < storage.size);
+#endif
+			return *(storage.buf + i);
+		}
+		const std::string &id_start = *global_autoidx_id_storage_.at(index_).prefix;
+		if (i < id_start.size())
+			return id_start[i];
+		i -= id_start.size();
+		std::string suffix = std::to_string(-index_);
+#ifndef NDEBUG
+		// Allow indexing to access the trailing null.
+		log_assert(i <= suffix.size());
 #endif
+		return suffix[i];
 	}
 
 	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);
+		std::string result;
+		const_iterator it = begin() + pos;
+		const_iterator end_it = end();
+		if (len != std::string::npos && len < it.size() - pos) {
+			end_it = it + len;
+		}
+		std::copy(it, end_it, std::back_inserter(result));
+		return result;
 	}
 
 	int compare(size_t pos, size_t len, const char* s) const {
-		return strncmp(c_str()+pos, s, len);
-	}
-
-	bool begins_with(const char* prefix) const {
-		size_t len = strlen(prefix);
-		if (size() < len) return false;
-		return compare(0, len, prefix) == 0;
+		const_iterator it = begin() + pos;
+		const_iterator end_it = end();
+		while (len > 0 && *s != 0 && it != end_it) {
+			int diff = *it - *s;
+			if (diff != 0)
+				return diff;
+			++it;
+			++s;
+			--len;
+		}
+		return 0;
+	}
+
+	bool begins_with(std::string_view prefix) const {
+		Substrings it = substrings();
+		std::string_view substr = it.first();
+		while (true) {
+			int min = std::min(GetSize(substr), GetSize(prefix));
+			if (memcmp(substr.data(), prefix.data(), min) != 0)
+				return false;
+			prefix = prefix.substr(min);
+			if (prefix.empty())
+				return true;
+			substr = substr.substr(min);
+			if (substr.empty()) {
+				if (std::optional<std::string_view> s = it.next())
+					substr = *s;
+				else
+					return false;
+			}
+		}
 	}
 
-	bool ends_with(const char* suffix) const {
-		size_t len = strlen(suffix);
-		if (size() < len) return false;
-		return compare(size()-len, len, suffix) == 0;
+	bool ends_with(std::string_view suffix) const {
+		size_t sz = size();
+		if (sz < suffix.size()) return false;
+		return compare(sz - suffix.size(), suffix.size(), suffix.data()) == 0;
 	}
 
-	bool contains(const char* str) const {
-		return strstr(c_str(), str);
+	bool contains(std::string_view s) const {
+		if (index_ >= 0)
+			return global_id_storage_.at(index_).str_view().find(s) != std::string::npos;
+		return str().find(s) != std::string::npos;
 	}
 
 	size_t size() const {
-		return strlen(c_str());
+		return begin().size();
 	}
 
 	bool empty() const {
@@ -458,7 +529,6 @@ struct RTLIL::IdString
 	}
 
 	bool in(const IdString &rhs) const { return *this == rhs; }
-	bool in(const StaticIdString &rhs) const { return *this == rhs; }
 	bool in(const char *rhs) const { return *this == rhs; }
 	bool in(const std::string &rhs) const { return *this == rhs; }
 	inline bool in(const pool<IdString> &rhs) const;
@@ -468,6 +538,14 @@ struct RTLIL::IdString
 
 private:
 	static void prepopulate();
+	static int really_insert(std::string_view p, std::unordered_map<std::string_view, int>::iterator &it);
+
+protected:
+	static IdString from_index(int index) {
+		IdString result;
+		result.index_ = index;
+		return result;
+	}
 
 public:
 	static void ensure_prepopulated() {
@@ -476,6 +554,95 @@ public:
 	}
 };
 
+struct RTLIL::OwningIdString : public RTLIL::IdString {
+	inline OwningIdString() { }
+	inline OwningIdString(const OwningIdString &str) : IdString(str) { get_reference(); }
+	inline OwningIdString(const char *str) : IdString(str) { get_reference(); }
+	inline OwningIdString(const IdString &str) : IdString(str) { get_reference(); }
+	inline OwningIdString(IdString &&str) : IdString(str) {	get_reference(); }
+	inline OwningIdString(const std::string &str) : IdString(str) { get_reference(); }
+	inline OwningIdString(std::string_view str) : IdString(str) { get_reference(); }
+	inline OwningIdString(StaticId id) : IdString(id) {}
+	inline ~OwningIdString() {
+		put_reference();
+	}
+
+	inline OwningIdString &operator=(const OwningIdString &rhs) {
+		put_reference();
+		index_ = rhs.index_;
+		get_reference();
+		return *this;
+	}
+	inline OwningIdString &operator=(const IdString &rhs) {
+		put_reference();
+		index_ = rhs.index_;
+		get_reference();
+		return *this;
+	}
+	inline OwningIdString &operator=(OwningIdString &&rhs) {
+		std::swap(index_, rhs.index_);
+		return *this;
+	}
+
+	// Collect all non-owning references.
+	static void collect_garbage();
+	static int64_t garbage_collection_ns() { return gc_ns; }
+	static int garbage_collection_count() { return gc_count; }
+
+	// Used by the ID() macro to create an IdString with no destructor whose string will
+	// never be released. If ID() creates a closure-static `OwningIdString` then
+	// initialization of the static registers its destructor to run at exit, which is
+	// wasteful.
+	static IdString immortal(const char* str) {
+		IdString result(str);
+		get_reference(result.index_);
+		return result;
+	}
+private:
+	static int64_t gc_ns;
+	static int gc_count;
+
+	void get_reference()
+	{
+		get_reference(index_);
+	}
+	static void get_reference(int idx)
+	{
+		log_assert(!Multithreading::active());
+
+		if (idx < static_cast<short>(StaticId::STATIC_ID_END))
+			return;
+		auto it = global_refcount_storage_.find(idx);
+		if (it == global_refcount_storage_.end())
+			global_refcount_storage_.insert(it, {idx, 1});
+		else
+			++it->second;
+	#ifdef YOSYS_XTRACE_GET_PUT
+		if (yosys_xtrace && idx >= static_cast<short>(StaticId::STATIC_ID_END))
+			log("#X# GET-BY-INDEX '%s' (index %d, refcount %u)\n", from_index(idx), idx, refcount(idx));
+	#endif
+	}
+
+	void put_reference()
+	{
+		log_assert(!Multithreading::active());
+
+		// put_reference() may be called from destructors after the destructor of
+		// global_refcount_storage_ has been run. in this case we simply do nothing.
+		if (index_ < static_cast<short>(StaticId::STATIC_ID_END) || !destruct_guard_ok)
+			return;
+	#ifdef YOSYS_XTRACE_GET_PUT
+		if (yosys_xtrace)
+			log("#X# PUT '%s' (index %d, refcount %u)\n", from_index(index_), index_, refcount(index_));
+	#endif
+		auto it = global_refcount_storage_.find(index_);
+		log_assert(it != global_refcount_storage_.end() && it->second >= 1);
+		if (--it->second == 0) {
+			global_refcount_storage_.erase(it);
+		}
+	}
+};
+
 namespace hashlib {
 	template <>
 	struct hash_ops<RTLIL::IdString> {
@@ -501,21 +668,9 @@ inline bool RTLIL::IdString::in(const pool<IdString> &rhs) const { return rhs.co
 [[deprecated]]
 inline bool RTLIL::IdString::in(const pool<IdString> &&rhs) const { return rhs.count(*this) != 0; }
 
-inline bool RTLIL::IdString::operator==(const RTLIL::StaticIdString &rhs) const {
-	return index_ == rhs.index();
-}
-inline bool RTLIL::IdString::operator!=(const RTLIL::StaticIdString &rhs) const {
-	return index_ != rhs.index();
-}
-
 namespace RTLIL {
-	namespace IDInternal {
-#define X(_id) extern const IdString _id;
-#include "kernel/constids.inc"
-#undef X
-	}
 	namespace ID {
-#define X(_id) constexpr StaticIdString _id(StaticId::_id, IDInternal::_id);
+#define X(_id) constexpr IdString _id(StaticId::_id);
 #include "kernel/constids.inc"
 #undef X
 	}
@@ -523,7 +678,7 @@ namespace RTLIL {
 
 struct IdTableEntry {
 	const std::string_view name;
-	const RTLIL::StaticIdString static_id;
+	const RTLIL::IdString static_id;
 };
 
 constexpr IdTableEntry IdTable[] = {
@@ -556,15 +711,15 @@ constexpr int lookup_well_known_id(std::string_view name)
 //
 //  sed -i.orig -r 's/"\\\\([a-zA-Z0-9_]+)"/ID(\1)/g; s/"(\$[a-zA-Z0-9_]+)"/ID(\1)/g;' <filename>
 //
-typedef const RTLIL::IdString &IDMacroHelperFunc();
+typedef RTLIL::IdString IDMacroHelperFunc();
 
 template <int IdTableIndex> struct IDMacroHelper {
-	static constexpr RTLIL::StaticIdString eval(IDMacroHelperFunc) {
+	static constexpr RTLIL::IdString eval(IDMacroHelperFunc) {
 		return IdTable[IdTableIndex].static_id;
 	}
 };
 template <> struct IDMacroHelper<-1> {
-	static constexpr const RTLIL::IdString &eval(IDMacroHelperFunc func) {
+	static constexpr RTLIL::IdString eval(IDMacroHelperFunc func) {
 		return func();
 	}
 };
@@ -574,16 +729,16 @@ template <> struct IDMacroHelper<-1> {
 		YOSYS_NAMESPACE_PREFIX IDMacroHelper< \
 				YOSYS_NAMESPACE_PREFIX lookup_well_known_id(#_id) \
 		>::eval([]() \
-		-> const YOSYS_NAMESPACE_PREFIX RTLIL::IdString & { \
+		-> YOSYS_NAMESPACE_PREFIX RTLIL::IdString { \
 			const char *p = "\\" #_id, *q = p[1] == '$' ? p+1 : p; \
-			static const YOSYS_NAMESPACE_PREFIX RTLIL::IdString id(q); \
+			static const YOSYS_NAMESPACE_PREFIX RTLIL::IdString id = \
+				YOSYS_NAMESPACE_PREFIX RTLIL::OwningIdString::immortal(q); \
 			return id; \
         })
 
 namespace RTLIL {
 	extern dict<std::string, std::string> constpad;
 
-	[[deprecated("Call cell->is_builtin_ff() instead")]]
 	const pool<IdString> &builtin_ff_cell_types();
 
 	static inline std::string escape_id(const std::string &str) {
@@ -620,13 +775,13 @@ namespace RTLIL {
 
 	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;
+			return a->name.lt_by_name(b->name);
 		}
 	};
 
 	struct sort_by_id_str {
 		bool operator()(const RTLIL::IdString &a, const RTLIL::IdString &b) const {
-			return strcmp(a.c_str(), b.c_str()) < 0;
+			return a.lt_by_name(b);
 		}
 	};
 
@@ -1581,6 +1736,8 @@ public:
 	operator std::vector<RTLIL::SigChunk>() const;
 	operator std::vector<RTLIL::SigBit>() const { return to_sigbit_vector(); }
 	const RTLIL::SigBit &at(int offset, const RTLIL::SigBit &defval) { return offset < size() ? (*this)[offset] : defval; }
+	RTLIL::SigBit& at(int offset) { return (*this)[offset]; }
+	RTLIL::SigBit at(int offset) const { return (*this)[offset]; }
 
 	[[nodiscard]] Hasher hash_into(Hasher h) const {
 		Hasher::hash_t val;
@@ -1876,9 +2033,7 @@ struct RTLIL::Design
 	// returns all selected unboxed whole modules, warning the user if any
 	// partially selected or boxed modules have been ignored
 	std::vector<RTLIL::Module*> selected_unboxed_whole_modules_warn() const { return selected_modules(SELECT_WHOLE_WARN, SB_UNBOXED_WARN); }
-#ifdef YOSYS_ENABLE_PYTHON
 	static std::map<unsigned int, RTLIL::Design*> *get_all_designs(void);
-#endif
 };
 
 struct RTLIL::Module : public RTLIL::NamedObject

yowasp_yosys/share/include/kernel/yosys_common.h

@@ -267,15 +267,41 @@ int ceil_log2(int x) YS_ATTRIBUTE(const);
 template<typename T> int GetSize(const T &obj) { return obj.size(); }
 inline int GetSize(RTLIL::Wire *wire);
 
-extern int autoidx;
+// When multiple threads are accessing RTLIL, one of these guard objects
+// must exist.
+struct Multithreading
+{
+	Multithreading();
+	~Multithreading();
+	// Returns true when multiple threads are accessing RTLIL.
+	// autoidx cannot be used during such times.
+	// IdStrings cannot be created during such times.
+	static bool active() { return active_; }
+private:
+	static bool active_;
+};
+
+struct Autoidx {
+	Autoidx(int value) : value(value) {}
+	operator int() const { return value; }
+	void ensure_at_least(int v);
+	int operator++(int);
+private:
+	int value;
+};
+
+extern Autoidx autoidx;
 extern int yosys_xtrace;
 extern bool yosys_write_versions;
 
-RTLIL::IdString new_id(std::string file, int line, std::string func);
-RTLIL::IdString new_id_suffix(std::string file, int line, std::string func, std::string suffix);
+const std::string *create_id_prefix(std::string_view file, int line, std::string_view func);
+RTLIL::IdString new_id_suffix(std::string_view file, int line, std::string_view func, std::string_view suffix);
 
 #define NEW_ID \
-	YOSYS_NAMESPACE_PREFIX new_id(__FILE__, __LINE__, __FUNCTION__)
+	YOSYS_NAMESPACE_PREFIX RTLIL::IdString::new_autoidx_with_prefix([](std::string_view func) -> const std::string * { \
+		static const std::string *prefix = YOSYS_NAMESPACE_PREFIX create_id_prefix(__FILE__, __LINE__, func); \
+		return prefix; \
+	}(__FUNCTION__))
 #define NEW_ID_SUFFIX(suffix) \
 	YOSYS_NAMESPACE_PREFIX new_id_suffix(__FILE__, __LINE__, __FUNCTION__, suffix)
 

yowasp_yosys/share/sdc/graph-stubs.sdc

@@ -0,0 +1,42 @@
+proc unknown {args} {
+    # Check if it's a getter
+    if {[llength $args] > 0} {
+        set first_arg [lindex $args 0]
+        if {[string match "get_*" $first_arg]} {
+            # It's a getter, has it been redirected from specialized C++ code?
+            if {[llength $args] > 1} {
+                set second_arg [lindex $args 1]
+                if {$second_arg ne "-getter-validated"} {
+                    error "Unknown getter: $first_arg"
+                }
+            } else {
+                error "Unknown getter: $first_arg"
+            }
+        }
+    }
+    # TODO this safety feature could be optional via a global
+
+    global sdc_call_index
+    global sdc_calls
+    if {![info exists sdc_call_index]} {
+        set sdc_call_index 0
+    }
+    if {![info exists sdc_calls]} {
+        set sdc_calls {}
+    }
+    set ret "YOSYS_SDC_MAGIC_NODE_$sdc_call_index"
+    incr sdc_call_index
+    lappend sdc_calls $args
+    # puts "unknown $args, returning YOSYS_SDC_MAGIC_NODE_$sdc_call_index"
+    return $ret
+}
+proc list {args} {
+    return [unknown "list" {*}$args]
+}
+proc get_clocks {args} {
+    # get_clocks isn't a design object getter
+    # because clocks aren't design objects, just aliases
+    # so the referred to clock pin already are being tracked
+    # as arguments of uninterpreted create_clock command or similar
+    return [unknown "get_clocks" "-getter-validated" {*}$args]
+}

{yowasp_yosys-0.59.0.0.post1038.dist-info → yowasp_yosys-0.60.0.0.post1055.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yowasp-yosys
-Version: 0.59.0.0.post1038
+Version: 0.60.0.0.post1055
 Summary: Yosys Open SYnthesis Suite
 Author-email: Catherine <whitequark@whitequark.org>
 License-Expression: ISC

{yowasp_yosys-0.59.0.0.post1038.dist-info → yowasp_yosys-0.60.0.0.post1055.dist-info}/RECORD

@@ -2,12 +2,11 @@ yowasp_yosys/__init__.py,sha256=cxu6bMlZ6zRpCzKp2wdFs7LNt5-btnJD6ghvdkDs6Y0,1189
 yowasp_yosys/sby.py,sha256=BZwSqLk064cKvGITogDi3OqlQtRJJ-8J4_KG5Z7ktoc,19736
 yowasp_yosys/smtbmc.py,sha256=kFTdW-sYuRU0f4YxRJuwYNIB1b9AFJeXM1sIIBdPJW0,74358
 yowasp_yosys/witness.py,sha256=m3iV2Nydm0p4G79VRaaX3lGul-nGnuxeKnx20MCJgi0,17279
-yowasp_yosys/yosys.wasm,sha256=sxVSHySsxE4--h41xnLvsh2fwRrKvBli6XerqyGrJpk,38857539
+yowasp_yosys/yosys.wasm,sha256=8x-WIGlfuAP07MDDJRSAmMWVFIbJ_yG__bZC8CKulbA,38249085
 yowasp_yosys/share/abc9_map.v,sha256=uWDqMpBQTeeadH1BlHVwkCy2StKF892xbgBgMKLK5-w,923
 yowasp_yosys/share/abc9_model.v,sha256=IfMyEGOEUBdZyiVule0wMhrVYVYQpmSIcxygbgtHItI,653
 yowasp_yosys/share/abc9_unmap.v,sha256=w107Y3iJjMU6D_6_aYLf2NziXTnAhpa5_CFAwaYO1iU,638
 yowasp_yosys/share/adff2dff.v,sha256=vrBTKA3JWb574eiFkrK-XMaPDW6lxXdpHk_Rfup86vI,575
-yowasp_yosys/share/cells.lib,sha256=ky_1Q27Tvqm2ksZuNABsZJAlBxjqrGdSbZQM2vGw7lE,2432
 yowasp_yosys/share/cmp2lcu.v,sha256=3UE5bFljaievVjQnb4JiQmROBGbAbvkbMJ0zuVaz_fI,5260
 yowasp_yosys/share/cmp2lut.v,sha256=DFxt94XQ-MMzz-3CoJvq4TD6XqtQU1tQdNWGvP9mdVk,2540
 yowasp_yosys/share/cmp2softlogic.v,sha256=IjDw9-8Rt8dqzhpoFx2mHRX8E5KbFewJYSBIgTtaJWs,2716
@@ -119,10 +118,10 @@ yowasp_yosys/share/include/kernel/cellaigs.h,sha256=CdYos67IpmAgLvBbJ8EC3hWg6WhB
 yowasp_yosys/share/include/kernel/celledges.h,sha256=fF_sHJOpN_qQ1P0x8KKoJE9ulDMusfjkF0dBpTMs19E,2216
 yowasp_yosys/share/include/kernel/celltypes.h,sha256=wO-YpmQMvOzSk-sX06kmND3TfsODAbYeqPIfH13uX5A,19355
 yowasp_yosys/share/include/kernel/consteval.h,sha256=lPo6CAW42gdhVLBTd-nBiIp25UrWIzR0f2R0JQo3Dzk,11038
-yowasp_yosys/share/include/kernel/constids.inc,sha256=tAdEAEoYBHLwTtYo55iLHgtUIJcVAtYtmpTo8KNxVtM,12900
+yowasp_yosys/share/include/kernel/constids.inc,sha256=AaGaUMW3jnbdKfG3RvgrXkQ0aM7M3Y3Wh6FzuzpWwLo,12927
 yowasp_yosys/share/include/kernel/cost.h,sha256=TRW3KGPVLv5MxAmNbSh1mnzwTc-QHvZXSh9Wfc6mw3U,2921
 yowasp_yosys/share/include/kernel/drivertools.h,sha256=jHPImO2CxM9Y7XzEIyDj8Z8agW8IUfQ41veC2g2OosM,33555
-yowasp_yosys/share/include/kernel/ff.h,sha256=vVJqxmyfJ1z9qnnUA3CAoX5NavU33_J4U1Sd7TgPp5M,7631
+yowasp_yosys/share/include/kernel/ff.h,sha256=DZTapOpnAa6ykHC3NBP6JxwSDnv0ICMrWYwYSQQSrcM,7805
 yowasp_yosys/share/include/kernel/ffinit.h,sha256=3O8XfLnskgmxpMUn9te-HI9XAa_BabBHs0l8ORBIxEo,3532
 yowasp_yosys/share/include/kernel/ffmerge.h,sha256=xl1_h88ZmLIxpli7vpiiU35R_Y4cZq728-A72abuzMg,6309
 yowasp_yosys/share/include/kernel/fmt.h,sha256=0UT-aDVX7_KnzlaNyK3iMsSzoICa4Q0HhqsFIrwHBMw,2790
@@ -130,13 +129,13 @@ yowasp_yosys/share/include/kernel/gzip.h,sha256=wpAZ9hA13HEpWgZnth46JHvVLSA_qdS-
 yowasp_yosys/share/include/kernel/hashlib.h,sha256=fPOd7Sy-ZAjWOOl2JNEg-f2BB2dobns9OENzZUhefGI,39598
 yowasp_yosys/share/include/kernel/io.h,sha256=7f9YHpRlplk9cskEYF4ZN7BahXq831McRkuHZ4-PeV4,15791
 yowasp_yosys/share/include/kernel/json.h,sha256=i2wmIMZ2SCE5zc6IIIVLx4XZ2-HQiZEFJ0ao_cMInK0,2849
-yowasp_yosys/share/include/kernel/log.h,sha256=4I4V4kUL77aTUIJuffooOEY_zpEqbIkqN_dXSEZ4A9E,16943
+yowasp_yosys/share/include/kernel/log.h,sha256=pB-dTx-quNH64wgF9pFKWRDSrqg8M2CwsbDzE27WFbI,17020
 yowasp_yosys/share/include/kernel/macc.h,sha256=pBdSo9tnjpOC77UUqFDzgQMzZCjixdhmOrLnSi9QUeI,8918
 yowasp_yosys/share/include/kernel/mem.h,sha256=2mCPY8QygVoDI1NC-cG0a0xaMwSihpcjfaGEyEDN7vs,15498
 yowasp_yosys/share/include/kernel/modtools.h,sha256=mRnzc5TIsdIbHlFSTk2Yc0y85ttknhK-dAlti3neSI8,14388
 yowasp_yosys/share/include/kernel/qcsat.h,sha256=ibhpJRu0youjDXPllXrDJi851VpwW1kbJ_y94_X6JhU,2804
-yowasp_yosys/share/include/kernel/register.h,sha256=jc3S7uED5yT-60fY_DhfrgRoy3Q_h8kVFaF_lc5JZyY,6789
-yowasp_yosys/share/include/kernel/rtlil.h,sha256=aTMkvAjWGgJq9o2MC-nqJcssg5nw8cEM1KbZhJ-50zU,111840
+yowasp_yosys/share/include/kernel/register.h,sha256=RY6IBb9hTKx9dY11He7eiCBmOEiyGenoD3qof6dJH_I,7987
+yowasp_yosys/share/include/kernel/rtlil.h,sha256=09Q1hJEkq_XD-_1K750JOymES_7B_idU2ZHftFcH27c,116926
 yowasp_yosys/share/include/kernel/satgen.h,sha256=KcGW7ofH4_oTw0TtT22-azGaOOc_2yCTsz6N1-AeDiY,10535
 yowasp_yosys/share/include/kernel/scopeinfo.h,sha256=EAU3vSTIwH1RrbSC7HVoTWh4SLfHMSIoidQPvT1Mo7g,11797
 yowasp_yosys/share/include/kernel/sexpr.h,sha256=CUDKFehVoGmakYBYLpEKUtlM0Dd3oI6TNW_cKz-qe0g,4720
@@ -145,7 +144,7 @@ yowasp_yosys/share/include/kernel/threading.h,sha256=OidU8rY1QCeTdMR6DD_heUg8BUO
 yowasp_yosys/share/include/kernel/timinginfo.h,sha256=JNRktUWp7ow_wn4P5BxlOkv7hNS7qKbws7Gjs6VSUx8,7367
 yowasp_yosys/share/include/kernel/utils.h,sha256=6WTFqPm117PbGUDjQVhFlzSnkuE8N2LfO2RXungS1xo,7925
 yowasp_yosys/share/include/kernel/yosys.h,sha256=g-tNpYJFkJtChmou9eVZxM7BFplJWra7WZ_y7hdRR_o,3454
-yowasp_yosys/share/include/kernel/yosys_common.h,sha256=xw4j8zqt_jIDk89UdSxk-liUTLvzovramI5fovEJ-AA,7847
+yowasp_yosys/share/include/kernel/yosys_common.h,sha256=fPQxbE7bjqcUl5nmHx7DH9uGbtBWe_vjOpQOOeNTJgw,8642
 yowasp_yosys/share/include/kernel/yw.h,sha256=Gr5zqBNUSKXOKhdw7tl9-KcCiZg3xFcK9Msj7LMawdI,5470
 yowasp_yosys/share/include/libs/ezsat/ezminisat.h,sha256=bSrDL6VRinpXdULoR8P9lQaT1Dy4kAEZfTcKjRKOdjg,2098
 yowasp_yosys/share/include/libs/ezsat/ezsat.h,sha256=eggeGwS9pFyxSYGT0RtOqX189pbXFAKDfPZzIYTmqIk,14523
@@ -297,6 +296,7 @@ yowasp_yosys/share/quicklogic/qlf_k6n10f/libmap_brams.txt,sha256=GKOIH1ZWb7jFLY0
 yowasp_yosys/share/quicklogic/qlf_k6n10f/libmap_brams_map.v,sha256=GgDi62vFlesuCXuhs5K6EY9bH7FGGCo59uMecNYbwKI,14121
 yowasp_yosys/share/quicklogic/qlf_k6n10f/sram1024x18_mem.v,sha256=tVO79TafQHC_V5vSii0soeaLTMoUrRCwDP3OCNFQThI,1128
 yowasp_yosys/share/quicklogic/qlf_k6n10f/ufifo_ctl.v,sha256=R2SalyyHfGSXyB6zhM88kjSiHht16s2HJMSZjoG5XKs,19068
+yowasp_yosys/share/sdc/graph-stubs.sdc,sha256=jcIgfT_DQtwgaYIgkVLRuBmTNJJu9pCxBITihHADeBw,1398
 yowasp_yosys/share/sf2/arith_map.v,sha256=8W5rnBPURSqALF2FpoMCTDfLnSFBo1te1-cigwdAtFI,1942
 yowasp_yosys/share/sf2/cells_map.v,sha256=er3vY75llifpyKNvJ7lZav__l5CboAGp9O8iVxOgpoU,1745
 yowasp_yosys/share/sf2/cells_sim.v,sha256=JEtn2ssacmkF1j-LO2w_JNxyUToCmDz0IlZUFYaue3U,8449
@@ -334,8 +334,8 @@ yowasp_yosys/share/xilinx/xc5v_dsp_map.v,sha256=I4lg0RQ54fBBba_7NNvUgwS4tQ1yLIsU
 yowasp_yosys/share/xilinx/xc6s_dsp_map.v,sha256=gTxHocB-Dn5G4BplWgri_tLhT6DIO2S0X-yu4iBKYyk,562
 yowasp_yosys/share/xilinx/xc7_dsp_map.v,sha256=zrzreQi7mElrAMtrayxtiO_Bw00S6zsjSjSVcjmJPH0,884
 yowasp_yosys/share/xilinx/xcu_dsp_map.v,sha256=gzCgl1emrHGcigVmU0nP0pW7dlhQ01SaWwXzHHcqt-o,882
-yowasp_yosys-0.59.0.0.post1038.dist-info/METADATA,sha256=gBpw9iqRyuHLxPP2shuF73aEHWD0GFp5x8T9KXecL-w,2523
-yowasp_yosys-0.59.0.0.post1038.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-yowasp_yosys-0.59.0.0.post1038.dist-info/entry_points.txt,sha256=p_9sIVi2ZqsqgYYo14PywYkwHYTa76fMEq3LxweXJpc,220
-yowasp_yosys-0.59.0.0.post1038.dist-info/top_level.txt,sha256=_yiNT8kLYkcD1TEuUCzQ_MkON1c3xuIRV59zXds4zd4,13
-yowasp_yosys-0.59.0.0.post1038.dist-info/RECORD,,
+yowasp_yosys-0.60.0.0.post1055.dist-info/METADATA,sha256=gGpDRSrohNQfGxdjcwyc84sHRv4vpGVbHNjAT81D41g,2523
+yowasp_yosys-0.60.0.0.post1055.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+yowasp_yosys-0.60.0.0.post1055.dist-info/entry_points.txt,sha256=p_9sIVi2ZqsqgYYo14PywYkwHYTa76fMEq3LxweXJpc,220
+yowasp_yosys-0.60.0.0.post1055.dist-info/top_level.txt,sha256=_yiNT8kLYkcD1TEuUCzQ_MkON1c3xuIRV59zXds4zd4,13
+yowasp_yosys-0.60.0.0.post1055.dist-info/RECORD,,

yowasp_yosys/share/cells.lib

@@ -1,108 +0,0 @@
-library(yosys_cells) {
-	cell(DFF_N) {
-		ff(IQ, IQN) {
-			clocked_on: "!C";
-			next_state: "D";
-		}
-		pin(D) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_P) {
-		ff(IQ, IQN) {
-			clocked_on: "C";
-			next_state: "D";
-		}
-		pin(D) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_NN0) {
-		ff(IQ, IQN) {
-			clocked_on: "!C";
-			next_state: "D";
-			clear: "!R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_NN1) {
-		ff(IQ, IQN) {
-			clocked_on: "!C";
-			next_state: "D";
-			preset: "!R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_NP0) {
-		ff(IQ, IQN) {
-			clocked_on: "!C";
-			next_state: "D";
-			clear: "R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_NP1) {
-		ff(IQ, IQN) {
-			clocked_on: "!C";
-			next_state: "D";
-			preset: "R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_PN0) {
-		ff(IQ, IQN) {
-			clocked_on: "C";
-			next_state: "D";
-			clear: "!R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_PN1) {
-		ff(IQ, IQN) {
-			clocked_on: "C";
-			next_state: "D";
-			preset: "!R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_PP0) {
-		ff(IQ, IQN) {
-			clocked_on: "C";
-			next_state: "D";
-			clear: "R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-	cell(DFF_PP1) {
-		ff(IQ, IQN) {
-			clocked_on: "C";
-			next_state: "D";
-			preset: "R";
-		}
-		pin(D) { direction: input; }
-		pin(R) { direction: input; }
-		pin(C) { direction: input; clock: true; }
-		pin(Q) { direction: output; function: "IQ"; }
-	}
-}