yowasp-yosys 0.55.0.3.post946.dev0__py3-none-any.whl → 0.56.0.0.post964__py3-none-any.whl

yowasp_yosys/sby.py

@@ -22,7 +22,7 @@ import json, os, sys, shutil, tempfile, re
 from sby_cmdline import parser_func
 from sby_core import SbyConfig, SbyTask, SbyAbort, SbyTaskloop, process_filename, dress_message
 from sby_jobserver import SbyJobClient, process_jobserver_environment
-from sby_status import SbyStatusDb
+from sby_status import SbyStatusDb, remove_db, FileInUseError
 import time, platform, click
 
 release_version = 'unknown SBY version'
@@ -54,6 +54,7 @@ dump_taskinfo = args.dump_taskinfo
 dump_files = args.dump_files
 reusedir = False
 setupmode = args.setupmode
+linkmode = args.linkmode
 autotune = args.autotune
 autotune_config = args.autotune_config
 sequential = args.sequential
@@ -61,8 +62,17 @@ jobcount = args.jobcount
 init_config_file = args.init_config_file
 status_show = args.status
 status_reset = args.status_reset
+status_cancels = args.status_cancels
+task_status = args.task_status
+status_live_formats = args.live_formats
+status_format = args.status_format
+status_latest = args.status_latest
+
+if autotune and linkmode:
+    print("ERROR: --link flag currently not available with --autotune")
+    sys.exit(1)
 
-if status_show or status_reset:
+if status_show or status_reset or task_status or status_format:
     target = workdir_prefix or workdir or sbyfile
     if target is None:
         print("ERROR: Specify a .sby config file or working directory to use --status.")
@@ -85,15 +95,29 @@ if status_show or status_reset:
 
     status_db = SbyStatusDb(status_path, task=None)
 
-    if status_show:
-        status_db.print_status_summary()
-        sys.exit(0)
-
     if status_reset:
         status_db.reset()
+    elif status_db.test_schema():
+        print(f"ERROR: Status database does not match expected format.  Use --statusreset to reset.")
+        sys.exit(1)
+
+    if status_show:
+        status_db.print_status_summary(status_latest)
+
+    if status_format:
+        status_db.print_status_summary_fmt(tasknames, status_format, status_latest)
+        
+    if task_status:
+        status_db.print_task_summary()
 
     status_db.db.close()
+
+    if status_live_formats:
+        print(f"WARNING: --live option found but not used.")
+
     sys.exit(0)
+elif status_latest:
+    print(f"WARNING: --latest flag found but not used.")
 
 
 if sbyfile is not None:
@@ -369,6 +393,7 @@ if dump_taskinfo:
             "mode": cfg.options.get("mode"),
             "engines": cfg.engines,
             "script": cfg.script,
+            "cancelledby": cfg.cancelledby,
         }
     print(json.dumps(taskinfo, indent=2))
     sys.exit(0)
@@ -450,6 +475,12 @@ def start_task(taskloop, taskname):
                 print("*", file=gitignore)
         with open(f"{my_workdir}/status.path", "w") as status_path:
             print(my_status_db, file=status_path)
+        if os.path.exists(f"{my_workdir}/{my_status_db}") and opt_force:
+            try:
+                remove_db(f"{my_workdir}/{my_status_db}")
+            except FileInUseError:
+                # don't delete an open database
+                pass
 
     junit_ts_name = os.path.basename(sbyfile[:-4]) if sbyfile is not None else workdir if workdir is not None else "stdin"
     junit_tc_name = taskname if taskname is not None else "default"
@@ -465,7 +496,7 @@ def start_task(taskloop, taskname):
     else:
         junit_filename = "junit"
 
-    task = SbyTask(sbyconfig, my_workdir, early_logmsgs, reusedir, taskloop)
+    task = SbyTask(sbyconfig, my_workdir, early_logmsgs, reusedir, status_cancels, taskloop, name=taskname, live_formats=status_live_formats)
 
     for k, v in exe_paths.items():
         task.exe_paths[k] = v
@@ -495,7 +526,7 @@ def start_task(taskloop, taskname):
     task.exit_callback = exit_callback
 
     if not autotune:
-        task.setup_procs(setupmode)
+        task.setup_procs(setupmode, linkmode)
         task.task_local_abort = not throw_err
 
     return task

yowasp_yosys/share/include/kernel/constids.inc

@@ -286,3 +286,4 @@ X(A_WIDTHS)
 X(B_WIDTHS)
 X(C_WIDTHS)
 X(C_SIGNED)
+X(raise_error)

yowasp_yosys/share/include/kernel/io.h

@@ -1,5 +1,6 @@
 #include <string>
 #include <stdarg.h>
+#include <type_traits>
 #include "kernel/yosys_common.h"
 
 #ifndef YOSYS_IO_H
@@ -50,18 +51,391 @@ inline std::string vstringf(const char *fmt, va_list ap)
 #endif
 }
 
-std::string stringf(const char *fmt, ...) YS_ATTRIBUTE(format(printf, 1, 2));
+enum ConversionSpecifier : uint8_t
+{
+	CONVSPEC_NONE,
+	// Specifier not understood/supported
+	CONVSPEC_ERROR,
+	// Consumes a "long long"
+	CONVSPEC_SIGNED_INT,
+	// Consumes a "unsigned long long"
+	CONVSPEC_UNSIGNED_INT,
+	// Consumes a "double"
+	CONVSPEC_DOUBLE,
+	// Consumes a "const char*" or other string type
+	CONVSPEC_CHAR_PTR,
+	// Consumes a "void*"
+	CONVSPEC_VOID_PTR,
+};
 
-inline std::string stringf(const char *fmt, ...)
+constexpr ConversionSpecifier parse_conversion_specifier(char ch, char prev_ch)
 {
-	std::string string;
-	va_list ap;
+	switch (ch) {
+	case 'd':
+	case 'i':
+		return CONVSPEC_SIGNED_INT;
+	case 'o':
+	case 'u':
+	case 'x':
+	case 'X':
+	case 'm':
+		return CONVSPEC_UNSIGNED_INT;
+	case 'c':
+		if (prev_ch == 'l' || prev_ch == 'q' || prev_ch == 'L') {
+			// wchar not supported
+			return CONVSPEC_ERROR;
+		}
+		return CONVSPEC_UNSIGNED_INT;
+	case 'e':
+	case 'E':
+	case 'f':
+	case 'F':
+	case 'g':
+	case 'G':
+	case 'a':
+	case 'A':
+		return CONVSPEC_DOUBLE;
+	case 's':
+		if (prev_ch == 'l' || prev_ch == 'q' || prev_ch == 'L') {
+			// wchar not supported
+			return CONVSPEC_ERROR;
+		}
+		return CONVSPEC_CHAR_PTR;
+	case 'p':
+		return CONVSPEC_VOID_PTR;
+	case '$': // positional parameters
+	case 'n':
+	case 'S':
+		return CONVSPEC_ERROR;
+	default:
+		return CONVSPEC_NONE;
+	}
+}
 
-	va_start(ap, fmt);
-	string = vstringf(fmt, ap);
-	va_end(ap);
+enum class DynamicIntCount : uint8_t {
+	NONE = 0,
+	ONE = 1,
+	TWO = 2,
+};
 
-	return string;
+// Describes a printf-style format conversion specifier found in a format string.
+struct FoundFormatSpec
+{
+	// The start offset of the conversion spec in the format string.
+	int start;
+	// The end offset of the conversion spec in the format string.
+	int end;
+	ConversionSpecifier spec;
+	// Number of int args consumed by '*' dynamic width/precision args.
+	DynamicIntCount num_dynamic_ints;
+};
+
+// Ensure there is no format spec.
+constexpr void ensure_no_format_spec(std::string_view fmt, int index, bool *has_escapes)
+{
+	int fmt_size = static_cast<int>(fmt.size());
+	// A trailing '%' is not a format spec.
+	while (index + 1 < fmt_size) {
+		if (fmt[index] != '%') {
+			++index;
+			continue;
+		}
+		if (fmt[index + 1] != '%') {
+			YOSYS_ABORT("More format conversion specifiers than arguments");
+		}
+		*has_escapes = true;
+		index += 2;
+	}
+}
+
+// Returns the next format conversion specifier (starting with '%').
+// Returns CONVSPEC_NONE if there isn't a format conversion specifier.
+constexpr FoundFormatSpec find_next_format_spec(std::string_view fmt, int fmt_start, bool *has_escapes)
+{
+	int index = fmt_start;
+	int fmt_size = static_cast<int>(fmt.size());
+	while (index < fmt_size) {
+		if (fmt[index] != '%') {
+			++index;
+			continue;
+		}
+		int p = index + 1;
+		uint8_t num_dynamic_ints = 0;
+		while (true) {
+			if (p == fmt_size) {
+				return {0, 0, CONVSPEC_NONE, DynamicIntCount::NONE};
+			}
+			if (fmt[p] == '%') {
+				*has_escapes = true;
+				index = p + 1;
+				break;
+			}
+			if (fmt[p] == '*') {
+				if (num_dynamic_ints >= 2) {
+					return {0, 0, CONVSPEC_ERROR, DynamicIntCount::NONE};
+				}
+				++num_dynamic_ints;
+			}
+			ConversionSpecifier spec = parse_conversion_specifier(fmt[p], fmt[p - 1]);
+			if (spec != CONVSPEC_NONE) {
+				return {index, p + 1, spec, static_cast<DynamicIntCount>(num_dynamic_ints)};
+			}
+			++p;
+		}
+	}
+	return {0, 0, CONVSPEC_NONE, DynamicIntCount::NONE};
+}
+
+template <typename... Args>
+constexpr typename std::enable_if<sizeof...(Args) == 0>::type
+check_format(std::string_view fmt, int fmt_start, bool *has_escapes, FoundFormatSpec*, DynamicIntCount)
+{
+	ensure_no_format_spec(fmt, fmt_start, has_escapes);
+}
+
+// Check that the format string `fmt.substr(fmt_start)` is valid for the given type arguments.
+// Fills `specs` with the FoundFormatSpecs found in the format string.
+// `int_args_consumed` is the number of int arguments already consumed to satisfy the
+// dynamic width/precision args for the next format conversion specifier.
+template <typename Arg, typename... Args>
+constexpr void check_format(std::string_view fmt, int fmt_start, bool *has_escapes, FoundFormatSpec* specs,
+        DynamicIntCount int_args_consumed)
+{
+	FoundFormatSpec found = find_next_format_spec(fmt, fmt_start, has_escapes);
+	if (found.num_dynamic_ints > int_args_consumed) {
+		// We need to consume at least one more int for the dynamic
+		// width/precision of this format conversion specifier.
+		if constexpr (!std::is_convertible_v<Arg, int>) {
+			YOSYS_ABORT("Expected dynamic int argument");
+		}
+		check_format<Args...>(fmt, fmt_start, has_escapes, specs,
+			static_cast<DynamicIntCount>(static_cast<uint8_t>(int_args_consumed) + 1));
+		return;
+	}
+	switch (found.spec) {
+	case CONVSPEC_NONE:
+		YOSYS_ABORT("Expected format conversion specifier for argument");
+		break;
+	case CONVSPEC_ERROR:
+		YOSYS_ABORT("Found unsupported format conversion specifier");
+		break;
+	case CONVSPEC_SIGNED_INT:
+		if constexpr (!std::is_convertible_v<Arg, long long>) {
+			YOSYS_ABORT("Expected type convertible to signed integer");
+		}
+		*specs = found;
+		break;
+	case CONVSPEC_UNSIGNED_INT:
+		if constexpr (!std::is_convertible_v<Arg, unsigned long long>) {
+			YOSYS_ABORT("Expected type convertible to unsigned integer");
+		}
+		*specs = found;
+		break;
+	case CONVSPEC_DOUBLE:
+		if constexpr (!std::is_convertible_v<Arg, double>) {
+			YOSYS_ABORT("Expected type convertible to double");
+		}
+		*specs = found;
+		break;
+	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 &>) {
+			YOSYS_ABORT("Expected type convertible to char *");
+		}
+		*specs = found;
+		break;
+	case CONVSPEC_VOID_PTR:
+		if constexpr (!std::is_convertible_v<Arg, const void *>) {
+			YOSYS_ABORT("Expected pointer type");
+		}
+		*specs = found;
+		break;
+	}
+	check_format<Args...>(fmt, found.end, has_escapes, specs + 1, DynamicIntCount::NONE);
+}
+
+// Emit the string representation of `arg` that has been converted to a `long long'.
+void format_emit_long_long(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, long long arg);
+
+// Emit the string representation of `arg` that has been converted to a `unsigned long long'.
+void format_emit_unsigned_long_long(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, unsigned long long arg);
+
+// Emit the string representation of `arg` that has been converted to a `double'.
+void format_emit_double(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, double arg);
+
+// Emit the string representation of `arg` that has been converted to a `const char*'.
+void format_emit_char_ptr(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, const char *arg);
+
+// Emit the string representation of `arg` that has been converted to a `std::string'.
+void format_emit_string(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, const std::string &arg);
+
+// Emit the string representation of `arg` that has been converted to a `std::string_view'.
+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 `double'.
+void format_emit_void_ptr(std::string &result, std::string_view spec, int *dynamic_ints,
+	DynamicIntCount num_dynamic_ints, const void *arg);
+
+// Emit the string representation of `arg` according to the given `FoundFormatSpec`,
+// appending it to `result`.
+template <typename Arg>
+inline void format_emit_one(std::string &result, std::string_view fmt, const FoundFormatSpec &ffspec,
+	int *dynamic_ints, const Arg& arg)
+{
+	std::string_view spec = fmt.substr(ffspec.start, ffspec.end - ffspec.start);
+	DynamicIntCount num_dynamic_ints = ffspec.num_dynamic_ints;
+	switch (ffspec.spec) {
+	case CONVSPEC_SIGNED_INT:
+		if constexpr (std::is_convertible_v<Arg, long long>) {
+			long long s = arg;
+			format_emit_long_long(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		break;
+	case CONVSPEC_UNSIGNED_INT:
+		if constexpr (std::is_convertible_v<Arg, unsigned long long>) {
+			unsigned long long s = arg;
+			format_emit_unsigned_long_long(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		break;
+	case CONVSPEC_DOUBLE:
+		if constexpr (std::is_convertible_v<Arg, double>) {
+			double s = arg;
+			format_emit_double(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		break;
+	case CONVSPEC_CHAR_PTR:
+		if constexpr (std::is_convertible_v<Arg, const char *>) {
+			const char *s = arg;
+			format_emit_char_ptr(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		if constexpr (std::is_convertible_v<Arg, const std::string &>) {
+			const std::string &s = arg;
+			format_emit_string(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		if constexpr (std::is_convertible_v<Arg, const std::string_view &>) {
+			const std::string_view &s = arg;
+			format_emit_string_view(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		break;
+	case CONVSPEC_VOID_PTR:
+		if constexpr (std::is_convertible_v<Arg, const void *>) {
+			const void *s = arg;
+			format_emit_void_ptr(result, spec, dynamic_ints, num_dynamic_ints, s);
+			return;
+		}
+		break;
+	default:
+		break;
+	}
+	YOSYS_ABORT("Internal error");
+}
+
+// Append the format string `fmt` to `result`, assuming there are no format conversion
+// specifiers other than "%%" and therefore no arguments. Unescape "%%".
+void format_emit_unescaped(std::string &result, std::string_view fmt);
+std::string unescape_format_string(std::string_view fmt);
+
+inline void format_emit(std::string &result, std::string_view fmt, int fmt_start,
+	bool has_escapes, const FoundFormatSpec*, int*, DynamicIntCount)
+{
+	fmt = fmt.substr(fmt_start);
+	if (has_escapes) {
+		format_emit_unescaped(result, fmt);
+	} else {
+		result += fmt;
+	}
+}
+// Format `args` according to `fmt` (starting at `fmt_start`) and `specs` and append to `result`.
+// `num_dynamic_ints` in `dynamic_ints[]` have already been collected to provide as
+// dynamic width/precision args for the next format conversion specifier.
+template <typename Arg, typename... Args>
+inline void format_emit(std::string &result, std::string_view fmt, int fmt_start, bool has_escapes,
+	const FoundFormatSpec* specs, int *dynamic_ints, DynamicIntCount num_dynamic_ints,
+	const Arg &arg, const Args &... args)
+{
+	if (specs->num_dynamic_ints > num_dynamic_ints) {
+		// Collect another int for the dynamic width precision/args
+		// for the next format conversion specifier.
+		if constexpr (std::is_convertible_v<Arg, int>) {
+			dynamic_ints[static_cast<uint8_t>(num_dynamic_ints)] = arg;
+		} else {
+			YOSYS_ABORT("Internal error");
+		}
+		format_emit(result, fmt, fmt_start, has_escapes, specs, dynamic_ints,
+		            static_cast<DynamicIntCount>(static_cast<uint8_t>(num_dynamic_ints) + 1), args...);
+		return;
+	}
+	std::string_view str = fmt.substr(fmt_start, specs->start - fmt_start);
+	if (has_escapes) {
+		format_emit_unescaped(result, str);
+	} else {
+		result += str;
+	}
+	format_emit_one(result, fmt, *specs, dynamic_ints, arg);
+	format_emit(result, fmt, specs->end, has_escapes, specs + 1, dynamic_ints, DynamicIntCount::NONE, args...);
+}
+
+template <typename... Args>
+inline std::string format_emit_toplevel(std::string_view fmt, bool has_escapes, const FoundFormatSpec* specs, const Args &... args)
+{
+	std::string result;
+	int dynamic_ints[2] = { 0, 0 };
+	format_emit(result, fmt, 0, has_escapes, specs, dynamic_ints, DynamicIntCount::NONE, args...);
+	return result;
+}
+template <>
+inline std::string format_emit_toplevel(std::string_view fmt, bool has_escapes, const FoundFormatSpec*)
+{
+	if (!has_escapes) {
+		return std::string(fmt);
+	}
+	return unescape_format_string(fmt);
+}
+
+// This class parses format strings to build a list of `FoundFormatSpecs` in `specs`.
+// When the compiler supports `consteval` (C++20), this parsing happens at compile time and
+// type errors will be reported at compile time. Otherwise the parsing happens at
+// runtime and type errors will trigger an `abort()` at runtime.
+template <typename... Args>
+class FmtString
+{
+public:
+	// Implicit conversion from const char * means that users can pass
+	// C string constants which are automatically parsed.
+	YOSYS_CONSTEVAL FmtString(const char *p) : fmt(p)
+	{
+		check_format<Args...>(fmt, 0, &has_escapes, specs, DynamicIntCount::NONE);
+	}
+	std::string format(const Args &... args)
+	{
+		return format_emit_toplevel(fmt, has_escapes, specs, args...);
+	}
+private:
+	std::string_view fmt;
+	bool has_escapes = false;
+	FoundFormatSpec specs[sizeof...(Args)] = {};
+};
+
+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)
+{
+	return fmt.format(args...);
 }
 
 int readsome(std::istream &f, char *s, int n);

yowasp_yosys/share/include/kernel/json.h

@@ -90,10 +90,10 @@ public:
     template<typename T>
     void array(const T &&values)
     {
-        begin_object();
+        begin_array();
         for (auto &item : values)
             value(item);
-        end_object();
+        end_array();
     }
 };
 

yowasp_yosys/share/include/kernel/register.h

@@ -23,27 +23,62 @@
 #include "kernel/yosys_common.h"
 #include "kernel/yosys.h"
 
+#ifdef YOSYS_ENABLE_HELP_SOURCE
+	#include <version>
+#	if __cpp_lib_source_location == 201907L
+		#include <source_location>
+		using std::source_location;
+		#define HAS_SOURCE_LOCATION
+#	elif defined(__has_include)
+#		if __has_include(<experimental/source_location>)
+			#include <experimental/source_location>
+			using std::experimental::source_location;
+			#define HAS_SOURCE_LOCATION
+#		endif
+#	endif
+#endif
+
+#ifndef HAS_SOURCE_LOCATION
+struct source_location { // dummy placeholder
+	int line() const { return 0; }
+	int column() const { return 0; }
+	const char* file_name() const { return "unknown"; }
+	const char* function_name() const { return "unknown"; }
+	static const source_location current(...) { return source_location(); }
+};
+#endif
+
 YOSYS_NAMESPACE_BEGIN
 
 struct Pass
 {
 	std::string pass_name, short_help;
-	Pass(std::string name, std::string short_help = "** document me **");
+	source_location location;
+	Pass(std::string name, std::string short_help = "** document me **",
+		source_location location = source_location::current());
 	// Prefer overriding 'Pass::on_shutdown()' if possible
 	virtual ~Pass();
 
+	// Makes calls to log() to generate help message
 	virtual void help();
+	// Uses PrettyHelp::get_current() to produce a more portable formatted help message
+	virtual bool formatted_help();
 	virtual void clear_flags();
 	virtual void execute(std::vector<std::string> args, RTLIL::Design *design) = 0;
 
 	int call_counter;
 	int64_t runtime_ns;
 	bool experimental_flag = false;
+	bool internal_flag = false;
 
 	void experimental() {
 		experimental_flag = true;
 	}
 
+	void internal() {
+		internal_flag = true;
+	}
+
 	struct pre_post_exec_state_t {
 		Pass *parent_pass;
 		int64_t begin_ns;
@@ -81,7 +116,8 @@ struct ScriptPass : Pass
 	RTLIL::Design *active_design;
 	std::string active_run_from, active_run_to;
 
-	ScriptPass(std::string name, std::string short_help = "** document me **") : Pass(name, short_help) { }
+	ScriptPass(std::string name, std::string short_help = "** document me **", source_location location = source_location::current()) :
+		Pass(name, short_help, location) { }
 
 	virtual void script() = 0;
 
@@ -99,7 +135,8 @@ struct Frontend : Pass
 	static std::string last_here_document;
 
 	std::string frontend_name;
-	Frontend(std::string name, std::string short_help = "** document me **");
+	Frontend(std::string name, std::string short_help = "** document me **",
+		source_location location = source_location::current());
 	void run_register() override;
 	~Frontend() override;
 	void execute(std::vector<std::string> args, RTLIL::Design *design) override final;
@@ -115,7 +152,8 @@ struct Frontend : Pass
 struct Backend : Pass
 {
 	std::string backend_name;
-	Backend(std::string name, std::string short_help = "** document me **");
+	Backend(std::string name, std::string short_help = "** document me **",
+		source_location location = source_location::current());
 	void run_register() override;
 	~Backend() override;
 	void execute(std::vector<std::string> args, RTLIL::Design *design) override final;

yowasp_yosys/share/include/kernel/rtlil.h

@@ -23,6 +23,9 @@
 #include "kernel/yosys_common.h"
 #include "kernel/yosys.h"
 
+#include <string_view>
+#include <unordered_map>
+
 YOSYS_NAMESPACE_BEGIN
 
 namespace RTLIL
@@ -122,7 +125,7 @@ struct RTLIL::IdString
 	} destruct_guard;
 
 	static std::vector<char*> global_id_storage_;
-	static dict<char*, int> global_id_index_;
+	static std::unordered_map<std::string_view, int> global_id_index_;
 #ifndef YOSYS_NO_IDS_REFCNT
 	static std::vector<int> global_refcount_storage_;
 	static std::vector<int> global_free_idx_list_;
@@ -1368,6 +1371,7 @@ struct RTLIL::Design
 	std::string scratchpad_get_string(const std::string &varname, const std::string &default_value = std::string()) const;
 
 	void sort();
+	void sort_modules();
 	void check();
 	void optimize();
 

yowasp_yosys/share/include/kernel/satgen.h

@@ -101,7 +101,9 @@ struct SatGen
 				else
 					vec.push_back(bit == (undef_mode ? RTLIL::State::Sx : RTLIL::State::S1) ? ez->CONST_TRUE : ez->CONST_FALSE);
 			} else {
-				std::string name = pf + (bit.wire->width == 1 ? stringf("%s", log_id(bit.wire)) : stringf("%s [%d]", log_id(bit.wire->name), bit.offset));
+				std::string wire_name = RTLIL::unescape_id(bit.wire->name);
+				std::string name = pf +
+					(bit.wire->width == 1 ? wire_name : stringf("%s [%d]", wire_name.c_str(), bit.offset));
 				vec.push_back(ez->frozen_literal(name));
 				imported_signals[pf][bit] = vec.back();
 			}

yowasp_yosys/share/include/kernel/yosys_common.h

@@ -134,6 +134,15 @@
 #  define YS_COLD
 #endif
 
+#ifdef __cpp_consteval
+#define YOSYS_CONSTEVAL consteval
+#else
+// If we can't use consteval we can at least make it constexpr.
+#define YOSYS_CONSTEVAL constexpr
+#endif
+
+#define YOSYS_ABORT(s) abort()
+
 #include "kernel/io.h"
 
 YOSYS_NAMESPACE_BEGIN