yowasp-yosys 0.55.0.3.post946.dev0__py3-none-any.whl → 0.56.0.141.post974.dev0__py3-none-any.whl

yowasp_yosys/share/include/kernel/sigtools.h

@@ -237,6 +237,42 @@ using sort_by_name_id_guard = typename std::enable_if<std::is_same<T,RTLIL::Cell
 template<typename T>
 class SigSet<T, sort_by_name_id_guard<T>> : public SigSet<T, RTLIL::sort_by_name_id<typename std::remove_pointer<T>::type>> {};
 
+struct SigMapView
+{
+	mfp<SigBit> database;
+
+	// Modify bit to its representative
+	void apply(RTLIL::SigBit &bit) const
+	{
+		bit = database.find(bit);
+	}
+
+	void apply(RTLIL::SigSpec &sig) const
+	{
+		for (auto &bit : sig)
+			apply(bit);
+	}
+
+	RTLIL::SigBit operator()(RTLIL::SigBit bit) const
+	{
+		apply(bit);
+		return bit;
+	}
+
+	RTLIL::SigSpec operator()(RTLIL::SigSpec sig) const
+	{
+		apply(sig);
+		return sig;
+	}
+
+	RTLIL::SigSpec operator()(RTLIL::Wire *wire) const
+	{
+		SigSpec sig(wire);
+		apply(sig);
+		return sig;
+	}
+};
+
 /**
  * SigMap wraps a union-find "database"
  * to map SigBits of a module to canonical representative SigBits.
@@ -244,10 +280,8 @@ class SigSet<T, sort_by_name_id_guard<T>> : public SigSet<T, RTLIL::sort_by_name
  * If a SigBit has a const state (impl: bit.wire is nullptr),
  * it's promoted to a representative.
  */
-struct SigMap
+struct SigMap final : public SigMapView
 {
-	mfp<SigBit> database;
-
 	SigMap(RTLIL::Module *module = NULL)
 	{
 		if (module != NULL)
@@ -320,45 +354,115 @@ struct SigMap
 
 	inline void add(Wire *wire) { return add(RTLIL::SigSpec(wire)); }
 
-	// Modify bit to its representative
-	void apply(RTLIL::SigBit &bit) const
+	// All non-const bits
+	RTLIL::SigSpec allbits() const
 	{
-		bit = database.find(bit);
+		RTLIL::SigSpec sig;
+		for (const auto &bit : database)
+			if (bit.wire != nullptr)
+				sig.append(bit);
+		return sig;
 	}
+};
 
-	void apply(RTLIL::SigSpec &sig) const
+/**
+ * SiValgMap wraps a union-find "database" to map SigBits of a module to
+ * canonical representative SigBits plus some optional Val value associated with the bits.
+ * Val has a commutative, associative, idempotent operator|=, a default constructor
+ * which constructs an identity element, and a copy constructor.
+ * SigBits that are connected share a set in the underlying database;
+ * the associated value is the "sum" of all the values associated with the contributing bits.
+ * If any of the SigBits in a set are a constant, the canonical SigBit is a constant.
+ */
+template <class Val>
+struct SigValMap final : public SigMapView
+{
+	dict<SigBit, Val> values;
+
+	void swap(SigValMap<Val> &other)
 	{
-		for (auto &bit : sig)
-			apply(bit);
+		database.swap(other.database);
+		values.swap(other.values);
 	}
 
-	RTLIL::SigBit operator()(RTLIL::SigBit bit) const
+	void clear()
 	{
-		apply(bit);
-		return bit;
+		database.clear();
+		values.clear();
 	}
 
-	RTLIL::SigSpec operator()(RTLIL::SigSpec sig) const
+	// Rebuild SigMap for all connections in module
+	void set(RTLIL::Module *module)
 	{
-		apply(sig);
-		return sig;
+		int bitcount = 0;
+		for (auto &it : module->connections())
+			bitcount += it.first.size();
+
+		database.clear();
+		values.clear();
+		database.reserve(bitcount);
+
+		for (auto &it : module->connections())
+			add(it.first, it.second);
 	}
 
-	RTLIL::SigSpec operator()(RTLIL::Wire *wire) const
+	// Add connections from "from" to "to", bit-by-bit.
+	void add(const RTLIL::SigSpec& from, const RTLIL::SigSpec& to)
 	{
-		SigSpec sig(wire);
-		apply(sig);
-		return sig;
+		log_assert(GetSize(from) == GetSize(to));
+
+		for (int i = 0; i < GetSize(from); i++)
+		{
+			int bfi = database.lookup(from[i]);
+			int bti = database.lookup(to[i]);
+			if (bfi == bti) {
+				continue;
+			}
+
+			const RTLIL::SigBit &bf = database[bfi];
+			const RTLIL::SigBit &bt = database[bti];
+			if (bf.wire == nullptr) {
+				// bf is constant so make it the canonical representative.
+				database.imerge(bti, bfi);
+				merge_value(bt, bf);
+			} else {
+				// Make bt the canonical representative.
+				database.imerge(bfi, bti);
+				merge_value(bf, bt);
+			}
+		}
 	}
 
-	// All non-const bits
-	RTLIL::SigSpec allbits() const
+	void addVal(const RTLIL::SigBit &bit, const Val &val)
 	{
-		RTLIL::SigSpec sig;
-		for (const auto &bit : database)
-			if (bit.wire != nullptr)
-				sig.append(bit);
-		return sig;
+		values[database.find(bit)] |= val;
+	}
+
+	void addVal(const RTLIL::SigSpec &sig, const Val &val)
+	{
+		for (const auto &bit : sig)
+			addVal(bit, val);
+	}
+
+	Val apply_and_get_value(RTLIL::SigBit &bit) const
+	{
+		bit = database.find(bit);
+		auto it = values.find(bit);
+		return it == values.end() ? Val() : it->second;
+	}
+
+private:
+	void merge_value(const RTLIL::SigBit &from, const RTLIL::SigBit &to)
+	{
+		auto it = values.find(from);
+		if (it == values.end()) {
+			return;
+		}
+		// values[to] could resize the underlying `entries` so
+		// finish using `it` first.
+		Val v = it->second;
+		values.erase(it);
+		values[to] |= v;
 	}
 };
 

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

yowasp_yosys/share/include/passes/techmap/libparse.h

@@ -0,0 +1,235 @@
+/*
+ *  yosys -- Yosys Open SYnthesis Suite
+ *
+ *  Copyright (C) 2012  Claire Xenia Wolf <claire@yosyshq.com>
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef LIBPARSE_H
+#define LIBPARSE_H
+
+#include "kernel/yosys.h"
+#include <stdio.h>
+#include <string>
+#include <vector>
+#include <set>
+
+/**
+ * This file is likely to change in the near future.
+ * Rely on it in your plugins at your own peril
+ */
+
+namespace Yosys
+{
+	struct LibertyAst
+	{
+		std::string id, value;
+		std::vector<std::string> args;
+		std::vector<LibertyAst*> children;
+		~LibertyAst();
+		const LibertyAst *find(std::string name) const;
+
+		typedef std::set<std::string> sieve;
+		void dump(FILE *f, sieve &blacklist, sieve &whitelist, std::string indent = "", std::string path = "", bool path_ok = false) const;
+	};
+
+	struct LibertyExpression
+	{
+		struct Lexer {
+			std::string s, expr;
+
+			Lexer(std::string s) : s{s}, expr{s} {}
+
+			bool empty() { return s.empty();}
+			char peek() { return s[0]; }
+			std::string full_expr() { return expr; }
+
+			char next() {
+				char c = s[0];
+				s = s.substr(1, s.size());
+				return c;
+			}
+
+			std::string pin() {
+				auto length = s.find_first_of("\t()'!^*& +|");
+				if (length == std::string::npos) {
+					// nothing found so use size of s
+					length = s.size();
+				}
+				auto pin = s.substr(0, length);
+				s = s.substr(length, s.size());
+				return pin;
+			}
+		};
+
+		enum Kind {
+			AND,
+			OR,
+			NOT,
+			XOR,
+			// the standard specifies constants, but they're probably rare in practice.
+			PIN,
+			EMPTY
+		};
+
+		Kind kind;
+		std::string name;
+		std::vector<LibertyExpression> children;
+
+		LibertyExpression() : kind(Kind::EMPTY) {}
+
+		static LibertyExpression parse(Lexer &s, int min_prio = 0);
+		void get_pin_names(pool<std::string>& names);
+		bool eval(dict<std::string, bool>& values);
+		std::string str(int indent = 0);
+	private:
+		static bool is_nice_binop(char c);
+	};
+
+	class LibertyInputStream {
+		std::istream &f;
+		std::vector<unsigned char> buffer;
+		size_t buf_pos = 0;
+		size_t buf_end = 0;
+		bool eof = false;
+
+		bool extend_buffer_once();
+		bool extend_buffer_at_least(size_t size = 1);
+
+		YS_COLD int get_cold();
+		YS_COLD int peek_cold(size_t offset);
+
+	public:
+		LibertyInputStream(std::istream &f) : f(f) {}
+
+		size_t buffered_size() { return buf_end - buf_pos; }
+		const unsigned char *buffered_data() { return buffer.data() + buf_pos; }
+
+		int get() {
+			if (buf_pos == buf_end)
+				return get_cold();
+			int c = buffer[buf_pos];
+			buf_pos += 1;
+			return c;
+		}
+
+		int peek(size_t offset = 0) {
+			if (buf_pos + offset >= buf_end)
+				return peek_cold(offset);
+			return buffer[buf_pos + offset];
+		}
+
+		void consume(size_t n = 1) {
+			buf_pos += n;
+		}
+
+		void unget() {
+			buf_pos -= 1;
+		}
+	};
+
+#ifndef FILTERLIB
+	class LibertyAstCache {
+		LibertyAstCache() {};
+		~LibertyAstCache() {};
+	public:
+		dict<std::string, std::shared_ptr<const LibertyAst>> cached;
+
+		bool cache_by_default = false;
+		bool verbose = false;
+		dict<std::string, bool> cache_path;
+
+		std::shared_ptr<const LibertyAst> cached_ast(const std::string &fname);
+		void parsed_ast(const std::string &fname, const std::shared_ptr<const LibertyAst> &ast);
+		static LibertyAstCache instance;
+	};
+#endif
+
+	class LibertyMergedCells;
+	class LibertyParser
+	{
+		friend class LibertyMergedCells;
+	private:
+		LibertyInputStream f;
+		int line;
+
+		/* lexer return values:
+		   'v': identifier, string, array range [...] -> str holds the token string
+		   'n': newline
+		   anything else is a single character.
+		*/
+		int lexer(std::string &str);
+
+		void report_unexpected_token(int tok);
+		void parse_vector_range(int tok);
+		LibertyAst *parse(bool top_level);
+		void error() const;
+		void error(const std::string &str) const;
+
+	public:
+		std::shared_ptr<const LibertyAst> shared_ast;
+		const LibertyAst *ast = nullptr;
+
+		LibertyParser(std::istream &f) : f(f), line(1) {
+			shared_ast.reset(parse(true));
+			ast = shared_ast.get();
+			if (!ast) {
+#ifdef FILTERLIB
+				fprintf(stderr, "No entries found in liberty file.\n");
+				exit(1);
+#else
+				log_error("No entries found in liberty file.\n");
+#endif
+			}
+		}
+
+#ifndef FILTERLIB
+		LibertyParser(std::istream &f, const std::string &fname) : f(f), line(1) {
+			shared_ast = LibertyAstCache::instance.cached_ast(fname);
+			if (!shared_ast) {
+				shared_ast.reset(parse(true));
+				LibertyAstCache::instance.parsed_ast(fname, shared_ast);
+			}
+			ast = shared_ast.get();
+			if (!ast) {
+				log_error("No entries found in liberty file `%s'.\n", fname.c_str());
+			}
+		}
+#endif
+	};
+
+	class LibertyMergedCells
+	{
+		std::vector<std::shared_ptr<const LibertyAst>> asts;
+
+	public:
+		std::vector<const LibertyAst *> cells;
+		void merge(LibertyParser &parser)
+		{
+			if (parser.ast) {
+				const LibertyAst *ast = parser.ast;
+				asts.push_back(parser.shared_ast);
+				if (ast->id != "library")
+					parser.error("Top level entity isn't \"library\".\n");
+				for (const LibertyAst *cell : ast->children)
+					if (cell->id == "cell" && cell->args.size() == 1)
+						cells.push_back(cell);
+			}
+		}
+	};
+
+}
+
+#endif

yowasp_yosys/share/python3/sby_autotune.py

@@ -649,7 +649,7 @@ class SbyAutotuneTask(SbyTask):
     def engine_list(self):
         return [(self.candidate.engine_idx, self.candidate.engine)]
 
-    def copy_src(self):
+    def copy_src(self, _):
         pass
 
     def model(self, model_name):

yowasp_yosys/share/python3/sby_cmdline.py

@@ -29,6 +29,8 @@ def parser_func(release_version='unknown SBY version'):
             help="maximum number of processes to run in parallel")
     parser.add_argument("--sequential", action="store_true", dest="sequential",
             help="run tasks in sequence, not in parallel")
+    parser.add_argument("--live", action="append", choices=["csv", "jsonl"], dest="live_formats",
+            help="print live updates of property statuses during task execution, may be specified multiple times")
 
     parser.add_argument("--autotune", action="store_true", dest="autotune",
             help="automatically find a well performing engine and engine configuration for each task")
@@ -70,11 +72,22 @@ def parser_func(release_version='unknown SBY version'):
             help="print the list of source files")
     parser.add_argument("--setup", action="store_true", dest="setupmode",
             help="set up the working directory and exit")
+    parser.add_argument("--link", action="store_true", dest="linkmode",
+            help="make symbolic links to source files instead of copying them")
 
     parser.add_argument("--status", action="store_true", dest="status",
             help="summarize the contents of the status database")
+    parser.add_argument("--statusfmt", action="store", default="", choices=["csv", "jsonl"], dest="status_format",
+            help="print the most recent status for each property in specified format")
+    parser.add_argument("--latest", action="store_true", dest="status_latest",
+            help="only check statuses from the most recent run of a task")
     parser.add_argument("--statusreset", action="store_true", dest="status_reset",
             help="reset the contents of the status database")
+    parser.add_argument("--statuscancels", action="store_true", dest="status_cancels",
+            help="intertask cancellations can be triggered by the status database")
+
+    parser.add_argument("--taskstatus", action="store_true", dest="task_status",
+            help="display the status of tasks in the status database")
 
     parser.add_argument("--init-config-file", dest="init_config_file",
             help="create a default .sby config file")