yowasp-yosys 0.56.0.141.post974.dev0__py3-none-any.whl → 0.58.0.0.post1010__py3-none-any.whl

yowasp_yosys/share/include/kernel/drivertools.h

@@ -20,6 +20,7 @@
 #ifndef DRIVERTOOLS_H
 #define DRIVERTOOLS_H
 
+#include <string>
 #include <type_traits>
 
 #include "kernel/rtlil.h"
@@ -39,11 +40,11 @@ struct DriveChunk;
 
 struct DriveSpec;
 
-const char *log_signal(DriveChunkWire const &chunk);
-const char *log_signal(DriveChunkPort const &chunk);
-const char *log_signal(DriveChunkMarker const &chunk);
-const char *log_signal(DriveChunk const &chunk);
-const char *log_signal(DriveSpec const &chunk);
+std::string log_signal(DriveChunkWire const &chunk);
+std::string log_signal(DriveChunkPort const &chunk);
+std::string log_signal(DriveChunkMarker const &chunk);
+std::string log_signal(DriveChunk const &chunk);
+std::string log_signal(DriveSpec const &chunk);
 
 enum class DriveType : unsigned char
 {

yowasp_yosys/share/include/kernel/ffinit.h

@@ -74,10 +74,10 @@ struct FfInitVals
 
 	RTLIL::Const operator()(const RTLIL::SigSpec &sig) const
 	{
-		RTLIL::Const res;
+		RTLIL::Const::Builder res_bits(GetSize(sig));
 		for (auto bit : sig)
-			res.bits().push_back((*this)(bit));
-		return res;
+			res_bits.push_back((*this)(bit));
+		return res_bits.build();
 	}
 
 	void set_init(RTLIL::SigBit bit, RTLIL::State val)
@@ -93,12 +93,12 @@ struct FfInitVals
 		initbits[mbit] = std::make_pair(val,abit);
 		auto it2 = abit.wire->attributes.find(ID::init);
 		if (it2 != abit.wire->attributes.end()) {
-			it2->second.bits()[abit.offset] = val;
+			it2->second.set(abit.offset, val);
 			if (it2->second.is_fully_undef())
 				abit.wire->attributes.erase(it2);
 		} else if (val != State::Sx) {
 			Const cval(State::Sx, GetSize(abit.wire));
-			cval.bits()[abit.offset] = val;
+			cval.set(abit.offset, val);
 			abit.wire->attributes[ID::init] = cval;
 		}
 	}

yowasp_yosys/share/include/kernel/hashlib.h

@@ -12,6 +12,7 @@
 #ifndef HASHLIB_H
 #define HASHLIB_H
 
+#include <array>
 #include <stdexcept>
 #include <algorithm>
 #include <optional>
@@ -100,7 +101,7 @@ private:
 		uint32_t hash = ((a << 5) + a) ^ b;
 		return hash;
 	}
-	public:
+public:
 	void hash32(uint32_t i) {
 		state = djb2_xor(i, state);
 		state = mkhash_xorshift(fudge ^ state);
@@ -113,7 +114,7 @@ private:
 		return;
 	}
 	[[nodiscard]]
-	hash_t yield() {
+	hash_t yield() const {
 		return (hash_t)state;
 	}
 
@@ -127,6 +128,7 @@ private:
 		*this = hash_ops<T>::hash_into(t, *this);
 	}
 
+	[[deprecated]]
 	void commutative_eat(hash_t t) {
 		state ^= t;
 	}
@@ -166,8 +168,17 @@ struct hash_ops {
 		} else if constexpr (std::is_pointer_v<T>) {
 			return hash_ops<uintptr_t>::hash_into((uintptr_t) a, h);
 		} else if constexpr (std::is_same_v<T, std::string>) {
-			for (auto c : a)
-				h.hash32(c);
+			int size = a.size();
+			int i = 0;
+			while (i + 8 < size) {
+				uint64_t v;
+				memcpy(&v, a.data() + i, 8);
+				h.hash64(v);
+				i += 8;
+			}
+			uint64_t v = 0;
+			memcpy(&v, a.data() + i, size - i);
+			h.hash64(v);
 			return h;
 		} else {
 			return a.hash_into(h);
@@ -177,58 +188,64 @@ struct hash_ops {
 };
 
 template<typename P, typename Q> struct hash_ops<std::pair<P, Q>> {
-	static inline bool cmp(std::pair<P, Q> a, std::pair<P, Q> b) {
+	static inline bool cmp(const std::pair<P, Q> &a, const std::pair<P, Q> &b) {
 		return a == b;
 	}
-	[[nodiscard]] static inline Hasher hash_into(std::pair<P, Q> a, Hasher h) {
+	[[nodiscard]] static inline Hasher hash_into(const std::pair<P, Q> &a, Hasher h) {
 		h = hash_ops<P>::hash_into(a.first, h);
 		h = hash_ops<Q>::hash_into(a.second, h);
 		return h;
 	}
-	HASH_TOP_LOOP_FST (std::pair<P, Q> a) HASH_TOP_LOOP_SND
+	HASH_TOP_LOOP_FST (const std::pair<P, Q> &a) HASH_TOP_LOOP_SND
+	[[nodiscard]] static inline Hasher hash(const P &p, const Q &q) {
+		Hasher h;
+		h = hash_ops<P>::hash_into(p, h);
+		h = hash_ops<Q>::hash_into(q, h);
+		return h;
+	}
 };
 
 template<typename... T> struct hash_ops<std::tuple<T...>> {
-	static inline bool cmp(std::tuple<T...> a, std::tuple<T...> b) {
+	static inline bool cmp(const std::tuple<T...> &a, const std::tuple<T...> &b) {
 		return a == b;
 	}
 	template<size_t I = 0>
-	static inline typename std::enable_if<I == sizeof...(T), Hasher>::type hash_into(std::tuple<T...>, Hasher h) {
+	static inline typename std::enable_if<I == sizeof...(T), Hasher>::type hash_into(const std::tuple<T...> &, Hasher h) {
 		return h;
 	}
 	template<size_t I = 0>
-	static inline typename std::enable_if<I != sizeof...(T), Hasher>::type hash_into(std::tuple<T...> a, Hasher h) {
+	static inline typename std::enable_if<I != sizeof...(T), Hasher>::type hash_into(const std::tuple<T...> &a, Hasher h) {
 		typedef hash_ops<typename std::tuple_element<I, std::tuple<T...>>::type> element_ops_t;
 		h = hash_into<I+1>(a, h);
 		h = element_ops_t::hash_into(std::get<I>(a), h);
 		return h;
 	}
-	HASH_TOP_LOOP_FST (std::tuple<T...> a) HASH_TOP_LOOP_SND
+	HASH_TOP_LOOP_FST (const std::tuple<T...> &a) HASH_TOP_LOOP_SND
 };
 
 template<typename T> struct hash_ops<std::vector<T>> {
-	static inline bool cmp(std::vector<T> a, std::vector<T> b) {
+	static inline bool cmp(const std::vector<T> &a, const std::vector<T> &b) {
 		return a == b;
 	}
-	[[nodiscard]] static inline Hasher hash_into(std::vector<T> a, Hasher h) {
+	[[nodiscard]] static inline Hasher hash_into(const std::vector<T> &a, Hasher h) {
 		h.eat((uint32_t)a.size());
 		for (auto k : a)
 			h.eat(k);
 		return h;
 	}
-	HASH_TOP_LOOP_FST (std::vector<T> a) HASH_TOP_LOOP_SND
+	HASH_TOP_LOOP_FST (const std::vector<T> &a) HASH_TOP_LOOP_SND
 };
 
 template<typename T, size_t N> struct hash_ops<std::array<T, N>> {
-    static inline bool cmp(std::array<T, N> a, std::array<T, N> b) {
+    static inline bool cmp(const std::array<T, N> &a, const std::array<T, N> &b) {
         return a == b;
     }
-    [[nodiscard]] static inline Hasher hash_into(std::array<T, N> a, Hasher h) {
+    [[nodiscard]] static inline Hasher hash_into(const std::array<T, N> &a, Hasher h) {
         for (const auto& k : a)
             h = hash_ops<T>::hash_into(k, h);
         return h;
     }
-	HASH_TOP_LOOP_FST (std::array<T, N> a) HASH_TOP_LOOP_SND
+	HASH_TOP_LOOP_FST (const std::array<T, N> &a) HASH_TOP_LOOP_SND
 };
 
 struct hash_cstr_ops {
@@ -300,10 +317,10 @@ template<> struct hash_ops<std::monostate> {
 };
 
 template<typename... T> struct hash_ops<std::variant<T...>> {
-	static inline bool cmp(std::variant<T...> a, std::variant<T...> b) {
+	static inline bool cmp(const std::variant<T...> &a, const std::variant<T...> &b) {
 		return a == b;
 	}
-	[[nodiscard]] static inline Hasher hash_into(std::variant<T...> a, Hasher h) {
+	[[nodiscard]] static inline Hasher hash_into(const std::variant<T...> &a, Hasher h) {
 		std::visit([& h](const auto &v) { h.eat(v); }, a);
 		h.eat(a.index());
 		return h;
@@ -311,10 +328,10 @@ template<typename... T> struct hash_ops<std::variant<T...>> {
 };
 
 template<typename T> struct hash_ops<std::optional<T>> {
-	static inline bool cmp(std::optional<T> a, std::optional<T> b) {
+	static inline bool cmp(const std::optional<T> &a, const std::optional<T> &b) {
 		return a == b;
 	}
-	[[nodiscard]] static inline Hasher hash_into(std::optional<T> a, Hasher h) {
+	[[nodiscard]] static inline Hasher hash_into(const std::optional<T> &a, Hasher h) {
 		if(a.has_value())
 			h.eat(*a);
 		else
@@ -356,6 +373,33 @@ template<typename K, int offset = 0, typename OPS = hash_ops<K>> class idict;
 template<typename K, typename OPS = hash_ops<K>> class pool;
 template<typename K, typename OPS = hash_ops<K>> class mfp;
 
+// Computes the hash value of an unordered set of elements.
+// See https://www.preprints.org/manuscript/201710.0192/v1/download.
+// This is the Sum(4) algorithm from that paper, which has good collision resistance,
+// much better than Sum(1) or Xor(1) (and somewhat better than Xor(4)).
+class commutative_hash {
+public:
+	commutative_hash() {
+		buckets.fill(0);
+	}
+	template <typename T>
+	void eat(const T &obj) {
+		eat(hash_ops<T>::hash(obj));
+	}
+	void eat(const Hasher &h) {
+		Hasher::hash_t v = h.yield();
+		size_t index = v & (buckets.size() - 1);
+		buckets[index] += v;
+	}
+	[[nodiscard]] Hasher hash_into(Hasher h) const {
+		for (auto b : buckets)
+			h.eat(b);
+		return h;
+	}
+private:
+	std::array<Hasher::hash_t, 4> buckets;
+};
+
 template<typename K, typename T, typename OPS>
 class dict {
 	struct entry_t
@@ -484,12 +528,11 @@ class dict {
 		return do_lookup_internal(key, hash);
 	}
 
-	int do_insert(const K &key, Hasher::hash_t &hash)
+	int do_insert(const K &key, const Hasher::hash_t &hash)
 	{
 		if (hashtable.empty()) {
 			entries.emplace_back(std::pair<K, T>(key, T()), -1);
 			do_rehash();
-			hash = do_hash(key);
 		} else {
 			entries.emplace_back(std::pair<K, T>(key, T()), hashtable[hash]);
 			hashtable[hash] = entries.size() - 1;
@@ -497,12 +540,11 @@ class dict {
 		return entries.size() - 1;
 	}
 
-	int do_insert(const std::pair<K, T> &value, Hasher::hash_t &hash)
+	int do_insert(const std::pair<K, T> &value, const Hasher::hash_t &hash)
 	{
 		if (hashtable.empty()) {
 			entries.emplace_back(value, -1);
 			do_rehash();
-			hash = do_hash(value.first);
 		} else {
 			entries.emplace_back(value, hashtable[hash]);
 			hashtable[hash] = entries.size() - 1;
@@ -510,13 +552,11 @@ class dict {
 		return entries.size() - 1;
 	}
 
-	int do_insert(std::pair<K, T> &&rvalue, Hasher::hash_t &hash)
+	int do_insert(std::pair<K, T> &&rvalue, const Hasher::hash_t &hash)
 	{
 		if (hashtable.empty()) {
-			auto key = rvalue.first;
 			entries.emplace_back(std::forward<std::pair<K, T>>(rvalue), -1);
 			do_rehash();
-			hash = do_hash(key);
 		} else {
 			entries.emplace_back(std::forward<std::pair<K, T>>(rvalue), hashtable[hash]);
 			hashtable[hash] = entries.size() - 1;
@@ -533,13 +573,16 @@ public:
 		int index;
 		const_iterator(const dict *ptr, int index) : ptr(ptr), index(index) { }
 	public:
-		typedef std::forward_iterator_tag iterator_category;
+		typedef std::bidirectional_iterator_tag iterator_category;
 		typedef std::pair<K, T> value_type;
 		typedef ptrdiff_t difference_type;
-		typedef std::pair<K, T>* pointer;
-		typedef std::pair<K, T>& reference;
+		typedef const std::pair<K, T>* pointer;
+		typedef const std::pair<K, T>& reference;
 		const_iterator() { }
 		const_iterator operator++() { index--; return *this; }
+		const_iterator operator++(int) { const_iterator tmp = *this; index--; return tmp; }
+		const_iterator operator--() { index++; return *this; }
+		const_iterator operator--(int) { const_iterator tmp = *this; index++; return tmp; }
 		const_iterator operator+=(int amt) { index -= amt; return *this; }
 		bool operator<(const const_iterator &other) const { return index > other.index; }
 		bool operator==(const const_iterator &other) const { return index == other.index; }
@@ -573,6 +616,13 @@ public:
 		const std::pair<K, T> *operator->() const { return &ptr->entries[index].udata; }
 		operator const_iterator() const { return const_iterator(ptr, index); }
 	};
+	using reverse_iterator = std::reverse_iterator<const_iterator>;
+	reverse_iterator rbegin() const {
+		return std::make_reverse_iterator(end());
+	}
+	reverse_iterator rend() const {
+		return std::make_reverse_iterator(begin());
+	}
 
 	constexpr dict()
 	{
@@ -801,14 +851,14 @@ public:
 	}
 
 	[[nodiscard]] Hasher hash_into(Hasher h) const {
+		commutative_hash comm;
 		for (auto &it : entries) {
 			Hasher entry_hash;
 			entry_hash.eat(it.udata.first);
 			entry_hash.eat(it.udata.second);
-			h.commutative_eat(entry_hash.yield());
+			comm.eat(entry_hash);
 		}
-		h.eat(entries.size());
-		return h;
+		return comm.hash_into(h);
 	}
 
 	void reserve(size_t n) { entries.reserve(n); }
@@ -822,7 +872,7 @@ public:
 
 	const_iterator begin() const { return const_iterator(this, int(entries.size())-1); }
 	const_iterator element(int n) const { return const_iterator(this, int(entries.size())-1-n); }
-	const_iterator end() const { return const_iterator(nullptr, -1); }
+	const_iterator end() const { return const_iterator(this, -1); }
 };
 
 template<typename K, typename OPS>
@@ -1184,11 +1234,11 @@ public:
 	}
 
 	[[nodiscard]] Hasher hash_into(Hasher h) const {
+		commutative_hash comm;
 		for (auto &it : entries) {
-			h.commutative_eat(ops.hash(it.udata).yield());
+			comm.eat(ops.hash(it.udata));
 		}
-		h.eat(entries.size());
-		return h;
+		return comm.hash_into(h);
 	}
 
 	void reserve(size_t n) { entries.reserve(n); }

yowasp_yosys/share/include/kernel/io.h

@@ -8,6 +8,10 @@
 
 YOSYS_NAMESPACE_BEGIN
 
+namespace RTLIL {
+	struct IdString;
+}
+
 inline std::string vstringf(const char *fmt, va_list ap)
 {
 	// For the common case of strings shorter than 128, save a heap
@@ -240,7 +244,8 @@ constexpr void check_format(std::string_view fmt, int fmt_start, bool *has_escap
 	case CONVSPEC_CHAR_PTR:
 		if constexpr (!std::is_convertible_v<Arg, const char *> &&
 		        !std::is_convertible_v<Arg, const std::string &> &&
-			!std::is_convertible_v<Arg, const std::string_view &>) {
+			!std::is_convertible_v<Arg, const std::string_view &> &&
+			!std::is_convertible_v<Arg, const RTLIL::IdString &>) {
 			YOSYS_ABORT("Expected type convertible to char *");
 		}
 		*specs = found;
@@ -279,6 +284,10 @@ void format_emit_string(std::string &result, std::string_view spec, int *dynamic
 void format_emit_string_view(std::string &result, std::string_view spec, int *dynamic_ints,
 	DynamicIntCount num_dynamic_ints, std::string_view arg);
 
+// Emit the string representation of `arg` that has been converted to a `RTLIL::IdString'.
+void format_emit_idstring(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, const RTLIL::IdString &arg);
+
 // Emit the string representation of `arg` that has been converted to a `double'.
 void format_emit_void_ptr(std::string &result, std::string_view spec, int *dynamic_ints,
 	DynamicIntCount num_dynamic_ints, const void *arg);
@@ -329,6 +338,11 @@ inline void format_emit_one(std::string &result, std::string_view fmt, const Fou
 			format_emit_string_view(result, spec, dynamic_ints, num_dynamic_ints, s);
 			return;
 		}
+		if constexpr (std::is_convertible_v<Arg, const RTLIL::IdString &>) {
+			const RTLIL::IdString &s = arg;
+			format_emit_idstring(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
 		break;
 	case CONVSPEC_VOID_PTR:
 		if constexpr (std::is_convertible_v<Arg, const void *>) {
@@ -423,6 +437,7 @@ public:
 	{
 		return format_emit_toplevel(fmt, has_escapes, specs, args...);
 	}
+	std::string_view format_string() const { return fmt; }
 private:
 	std::string_view fmt;
 	bool has_escapes = false;
@@ -433,7 +448,7 @@ template <typename T> struct WrapType { using type = T; };
 template <typename T> using TypeIdentity = typename WrapType<T>::type;
 
 template <typename... Args>
-inline std::string stringf(FmtString<TypeIdentity<Args>...> fmt, Args... args)
+inline std::string stringf(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
 {
 	return fmt.format(args...);
 }

yowasp_yosys/share/include/kernel/log.h

@@ -119,30 +119,12 @@ extern int log_make_debug;
 extern int log_force_debug;
 extern int log_debug_suppressed;
 
-void logv(const char *format, va_list ap);
-void logv_header(RTLIL::Design *design, const char *format, va_list ap);
-void logv_warning(const char *format, va_list ap);
-void logv_warning_noprefix(const char *format, va_list ap);
-[[noreturn]] void logv_error(const char *format, va_list ap);
+[[deprecated]]
 [[noreturn]] void logv_file_error(const string &filename, int lineno, const char *format, va_list ap);
 
-void log(const char *format, ...)  YS_ATTRIBUTE(format(printf, 1, 2));
-void log_header(RTLIL::Design *design, const char *format, ...) YS_ATTRIBUTE(format(printf, 2, 3));
-void log_warning(const char *format, ...) YS_ATTRIBUTE(format(printf, 1, 2));
-void log_experimental(const char *format, ...) YS_ATTRIBUTE(format(printf, 1, 2));
-
 void set_verific_logging(void (*cb)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg));
 extern void (*log_verific_callback)(int msg_type, const char *message_id, const char* file_path, unsigned int left_line, unsigned int left_col, unsigned int right_line, unsigned int right_col, const char *msg);
 
-// Log with filename to report a problem in a source file.
-void log_file_warning(const std::string &filename, int lineno, const char *format, ...) YS_ATTRIBUTE(format(printf, 3, 4));
-void log_file_info(const std::string &filename, int lineno, const char *format, ...) YS_ATTRIBUTE(format(printf, 3, 4));
-
-void log_warning_noprefix(const char *format, ...) YS_ATTRIBUTE(format(printf, 1, 2));
-[[noreturn]] void log_error(const char *format, ...) YS_ATTRIBUTE(format(printf, 1, 2));
-[[noreturn]] void log_file_error(const string &filename, int lineno, const char *format, ...) YS_ATTRIBUTE(format(printf, 3, 4));
-[[noreturn]] void log_cmd_error(const char *format, ...) YS_ATTRIBUTE(format(printf, 1, 2));
-
 #ifndef NDEBUG
 static inline bool ys_debug(int n = 0) { if (log_force_debug) return true; log_debug_suppressed += n; return false; }
 #else
@@ -150,6 +132,79 @@ static inline bool ys_debug(int = 0) { return false; }
 #endif
 #  define log_debug(...) do { if (ys_debug(1)) log(__VA_ARGS__); } while (0)
 
+void log_formatted_string(std::string_view format, std::string str);
+template <typename... Args>
+inline void log(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	if (log_make_debug && !ys_debug(1))
+		return;
+	log_formatted_string(fmt.format_string(), fmt.format(args...));
+}
+
+void log_formatted_header(RTLIL::Design *design, std::string_view format, std::string str);
+template <typename... Args>
+inline void log_header(RTLIL::Design *design, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_header(design, fmt.format_string(), fmt.format(args...));
+}
+
+void log_formatted_warning(std::string_view prefix, std::string str);
+template <typename... Args>
+inline void log_warning(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_warning("Warning: ", fmt.format(args...));
+}
+
+inline void log_formatted_warning_noprefix(std::string str)
+{
+	log_formatted_warning("", str);
+}
+template <typename... Args>
+inline void log_warning_noprefix(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_warning("", fmt.format(args...));
+}
+
+void log_experimental(const std::string &str);
+
+// Log with filename to report a problem in a source file.
+void log_formatted_file_warning(std::string_view filename, int lineno, std::string str);
+template <typename... Args>
+void log_file_warning(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_file_warning(filename, lineno, fmt.format(args...));
+}
+
+void log_formatted_file_info(std::string_view filename, int lineno, std::string str);
+template <typename... Args>
+void log_file_info(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	if (log_make_debug && !ys_debug(1))
+		return;
+	log_formatted_file_info(filename, lineno, fmt.format(args...));
+}
+
+[[noreturn]] void log_formatted_error(std::string str);
+template <typename... Args>
+[[noreturn]] void log_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_error(fmt.format(args...));
+}
+
+[[noreturn]] void log_formatted_file_error(std::string_view filename, int lineno, std::string str);
+template <typename... Args>
+[[noreturn]] void log_file_error(std::string_view filename, int lineno, FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_file_error(filename, lineno, fmt.format(args...));
+}
+
+[[noreturn]] void log_formatted_cmd_error(std::string str);
+template <typename... Args>
+[[noreturn]] void log_cmd_error(FmtString<TypeIdentity<Args>...> fmt, const Args &... args)
+{
+	log_formatted_cmd_error(fmt.format(args...));
+}
+
 static inline void log_suppressed() {
 	if (log_debug_suppressed && !log_make_debug) {
 		log("<suppressed ~%d debug messages>\n", log_debug_suppressed);
@@ -204,11 +259,9 @@ extern dict<std::string, LogExpectedItem> log_expect_log, log_expect_warning, lo
 extern dict<std::string, LogExpectedItem> log_expect_prefix_log, log_expect_prefix_warning, log_expect_prefix_error;
 void log_check_expected();
 
-const char *log_signal(const RTLIL::SigSpec &sig, bool autoint = true);
-const char *log_const(const RTLIL::Const &value, bool autoint = true);
+std::string log_signal(const RTLIL::SigSpec &sig, bool autoint = true);
+std::string log_const(const RTLIL::Const &value, bool autoint = true);
 const char *log_id(const RTLIL::IdString &id);
-const char *log_str(const char *str);
-const char *log_str(std::string const &str);
 
 template<typename T> static inline const char *log_id(T *obj, const char *nullstr = nullptr) {
 	if (nullstr && obj == nullptr)
@@ -220,16 +273,20 @@ void log_module(RTLIL::Module *module, std::string indent = "");
 void log_cell(RTLIL::Cell *cell, std::string indent = "");
 void log_wire(RTLIL::Wire *wire, std::string indent = "");
 
+[[noreturn]]
+void log_assert_failure(const char *expr, const char *file, int line);
 #ifndef NDEBUG
 static inline void log_assert_worker(bool cond, const char *expr, const char *file, int line) {
-	if (!cond) log_error("Assert `%s' failed in %s:%d.\n", expr, file, line);
+	if (!cond) log_assert_failure(expr, file, line);
 }
 #  define log_assert(_assert_expr_) YOSYS_NAMESPACE_PREFIX log_assert_worker(_assert_expr_, #_assert_expr_, __FILE__, __LINE__)
 #else
 #  define log_assert(_assert_expr_) do { if (0) { (void)(_assert_expr_); } } while(0)
 #endif
 
-#define log_abort() YOSYS_NAMESPACE_PREFIX log_error("Abort in %s:%d.\n", __FILE__, __LINE__)
+[[noreturn]]
+void log_abort_internal(const char *file, int line);
+#define log_abort() YOSYS_NAMESPACE_PREFIX log_abort_internal(__FILE__, __LINE__)
 #define log_ping() YOSYS_NAMESPACE_PREFIX log("-- %s:%d %s --\n", __FILE__, __LINE__, __PRETTY_FUNCTION__)
 
 
@@ -351,13 +408,27 @@ static inline void log_dump_val_worker(unsigned long int v) { log("%lu", v); }
 static inline void log_dump_val_worker(long long int v) { log("%lld", v); }
 static inline void log_dump_val_worker(unsigned long long int v) { log("%lld", v); }
 #endif
-static inline void log_dump_val_worker(char c) { log(c >= 32 && c < 127 ? "'%c'" : "'\\x%02x'", c); }
-static inline void log_dump_val_worker(unsigned char c) { log(c >= 32 && c < 127 ? "'%c'" : "'\\x%02x'", c); }
+static inline void log_dump_val_worker(char c)
+{
+	if (c >= 32 && c < 127) {
+		log("'%c'", c);
+	} else {
+		log("'\\x%02x'", c);
+	}
+}
+static inline void log_dump_val_worker(unsigned char c)
+{
+	if (c >= 32 && c < 127) {
+		log("'%c'", c);
+	} else {
+		log("'\\x%02x'", c);
+	}
+}
 static inline void log_dump_val_worker(bool v) { log("%s", v ? "true" : "false"); }
 static inline void log_dump_val_worker(double v) { log("%f", v); }
 static inline void log_dump_val_worker(char *v) { log("%s", v); }
 static inline void log_dump_val_worker(const char *v) { log("%s", v); }
-static inline void log_dump_val_worker(std::string v) { log("%s", v.c_str()); }
+static inline void log_dump_val_worker(std::string v) { log("%s", v); }
 static inline void log_dump_val_worker(PerformanceTimer p) { log("%f seconds", p.sec()); }
 static inline void log_dump_args_worker(const char *p) { log_assert(*p == 0); }
 void log_dump_val_worker(RTLIL::IdString v);
@@ -374,7 +445,7 @@ static inline void log_dump_val_worker(dict<K, T> &v) {
 	log("{");
 	bool first = true;
 	for (auto &it : v) {
-		log(first ? " " : ", ");
+		log("%s ", first ? "" : ",");
 		log_dump_val_worker(it.first);
 		log(": ");
 		log_dump_val_worker(it.second);
@@ -388,7 +459,7 @@ static inline void log_dump_val_worker(pool<K> &v) {
 	log("{");
 	bool first = true;
 	for (auto &it : v) {
-		log(first ? " " : ", ");
+		log("%s ", first ? "" : ",");
 		log_dump_val_worker(it);
 		first = false;
 	}
@@ -400,7 +471,7 @@ static inline void log_dump_val_worker(std::vector<K> &v) {
 	log("{");
 	bool first = true;
 	for (auto &it : v) {
-		log(first ? " " : ", ");
+		log("%s ", first ? "" : ",");
 		log_dump_val_worker(it);
 		first = false;
 	}

yowasp_yosys/share/include/kernel/macc.h

@@ -262,7 +262,7 @@ struct Macc
 
 	bool eval(RTLIL::Const &result) const
 	{
-		for (auto &bit : result.bits())
+		for (auto bit : result)
 			bit = State::S0;
 
 		for (auto &port : terms)

yowasp_yosys/share/include/kernel/mem.h

@@ -255,11 +255,13 @@ private:
 	// return the offset the addr would have in the range at `it`
 	size_t _range_offset(std::map<addr_t, RTLIL::Const>::iterator it, addr_t addr) const { return (addr - it->first) * _data_width; }
 	// assuming _range_contains(it, addr), return an iterator pointing to the data at addr
-	std::vector<State>::iterator _range_data(std::map<addr_t, RTLIL::Const>::iterator it, addr_t addr) { return it->second.bits().begin() + _range_offset(it, addr); }
+	RTLIL::Const::iterator _range_data(std::map<addr_t, RTLIL::Const>::iterator it, addr_t addr) {
+		return RTLIL::Const::iterator(it->second, _range_offset(it, addr));
+	}
 	// internal version of reserve_range that returns an iterator to the range
 	std::map<addr_t, RTLIL::Const>::iterator _reserve_range(addr_t begin_addr, addr_t end_addr);
 	// write a single word at addr, return iterator to next word
-	std::vector<State>::iterator _range_write(std::vector<State>::iterator it, RTLIL::Const const &data);
+	RTLIL::Const::iterator _range_write(RTLIL::Const::iterator it, RTLIL::Const const &data);
 public:
 	class range {
 		int _data_width;