+ - python3

+ - libboost-system-dev

+ - libboost-python-dev

+ - libboost-filesystem-dev

+ - python3

+ - libboost-system-dev

+ - libboost-python-dev

+ - libboost-filesystem-dev

+ - python3

+ - libboost-system-dev

+ - libboost-python-dev

+ - libboost-filesystem-dev

+ - python3

+ - libboost-system-dev

+ - libboost-python-dev

+ - libboost-filesystem-dev

+ - python3

+ - libboost-system-dev

+ - libboost-python-dev

+ - libboost-filesystem-dev

+ - "synth_xilinx" to now infer hard shift registers, using new "shregmap -tech xilinx"

+# python wrappers

+ENABLE_PYOSYS := 0

+PYTHON_VERSION_TESTCODE := "import sys;t='{v[0]}.{v[1]}'.format(v=list(sys.version_info[:2]));print(t)"

+PYTHON_EXECUTABLE := $(shell if python3 -c ""; then echo "python3"; else echo "python"; fi)

+PYTHON_VERSION := $(shell $(PYTHON_EXECUTABLE) -c ""$(PYTHON_VERSION_TESTCODE)"")

+PYTHON_MAJOR_VERSION := $(shell echo $(PYTHON_VERSION) | cut -f1 -d.)

+PYTHON_DESTDIR := `$(PYTHON_EXECUTABLE)-config --prefix`/lib/python$(PYTHON_VERSION)/dist-packages

+

+ABCREV = 3709744

+ifeq ($(ENABLE_PYOSYS),1)

+

+#Detect name of boost_python library. Some distros usbe boost_python-py<version>, other boost_python<version>, some only use the major version number, some a concatenation of major and minor version numbers

+BOOST_PYTHON_LIB ?= $(shell \

+ if echo "int main(int argc, char ** argv) {return 0;}" | $(CXX) -xc -o /dev/null `$(PYTHON_EXECUTABLE)-config --libs` -lboost_python-py$(subst .,,$(PYTHON_VERSION)) - > /dev/null 2>&1; then echo "-lboost_python-py$(subst .,,$(PYTHON_VERSION))"; else \

+ if echo "int main(int argc, char ** argv) {return 0;}" | $(CXX) -xc -o /dev/null `$(PYTHON_EXECUTABLE)-config --libs` -lboost_python-py$(subst .,,$(PYTHON_MAJOR_VERSION)) - > /dev/null 2>&1; then echo "-lboost_python-py$(subst .,,$(PYTHON_MAJOR_VERSION))"; else \

+ if echo "int main(int argc, char ** argv) {return 0;}" | $(CXX) -xc -o /dev/null `$(PYTHON_EXECUTABLE)-config --libs` -lboost_python$(subst .,,$(PYTHON_VERSION)) - > /dev/null 2>&1; then echo "-lboost_python$(subst .,,$(PYTHON_VERSION))"; else \

+ if echo "int main(int argc, char ** argv) {return 0;}" | $(CXX) -xc -o /dev/null `$(PYTHON_EXECUTABLE)-config --libs` -lboost_python$(subst .,,$(PYTHON_MAJOR_VERSION)) - > /dev/null 2>&1; then echo "-lboost_python$(subst .,,$(PYTHON_MAJOR_VERSION))"; else \

+ echo ""; fi; fi; fi; fi;)

+

+ifeq ($(BOOST_PYTHON_LIB),)

+$(error BOOST_PYTHON_LIB could not be detected. Please define manualy)

+endif

+

+ifeq ($(PYTHON_MAJOR_VERSION),3)

+LDLIBS += `$(PYTHON_EXECUTABLE)-config --libs` $(BOOST_PYTHON_LIB) -lboost_system -lboost_filesystem

+CXXFLAGS += `$(PYTHON_EXECUTABLE)-config --includes` -D WITH_PYTHON

+else

+LDLIBS += `$(PYTHON_EXECUTABLE)-config --libs` $(BOOST_PYTHON_LIB) -lboost_system -lboost_filesystem

+CXXFLAGS += `$(PYTHON_EXECUTABLE)-config --includes` -D WITH_PYTHON

+endif

+

+PY_WRAPPER_FILE = kernel/python_wrappers

+OBJS += $(PY_WRAPPER_FILE).o

+PY_GEN_SCRIPT= py_wrap_generator

+PY_WRAP_INCLUDES := $(shell python$(PYTHON_VERSION) -c "from misc import $(PY_GEN_SCRIPT); $(PY_GEN_SCRIPT).print_includes()")

+endif

+

+%.pyh: %.h

+ $(Q) mkdir -p $(dir $@)

+ $(P) cat $< | grep -E -v "#[ ]*(include|error)" | $(LD) -x c++ -o $@ -E -P -

+

+$(PY_WRAPPER_FILE).cc: misc/$(PY_GEN_SCRIPT).py $(PY_WRAP_INCLUDES)

+ $(Q) mkdir -p $(dir $@)

+ $(P) python$(PYTHON_VERSION) -c "from misc import $(PY_GEN_SCRIPT); $(PY_GEN_SCRIPT).gen_wrappers(\"$(PY_WRAPPER_FILE).cc\")"

+

+ifeq ($(ENABLE_PYOSYS),1)

+ $(INSTALL_SUDO) mkdir -p $(PYTHON_DESTDIR)/pyosys

+ $(INSTALL_SUDO) cp libyosys.so $(PYTHON_DESTDIR)/pyosys

+ $(INSTALL_SUDO) cp misc/__init__.py $(PYTHON_DESTDIR)/pyosys

+endif

+ifeq ($(ENABLE_PYOSYS),1)

+ $(INSTALL_SUDO) rm -vf $(PYTHON_DESTDIR)/pyosys/libyosys.so

+ $(INSTALL_SUDO) rm -vf $(PYTHON_DESTDIR)/pyosys/__init__.py

+ $(INSTALL_SUDO) rmdir $(PYTHON_DESTDIR)/pyosys

+endif

+ rm -rf kernel/*.pyh

+ rm -f $(OBJS) $(GENFILES) $(TARGETS) $(EXTRA_TARGETS) $(EXTRA_OBJS) $(PY_WRAP_INCLUDES) $(PY_WRAPPER_FILE).cc

+ graphviz xdot pkg-config python3 libboost-system-dev \

+ libboost-python-dev libboost-filesystem-dev

+ git graphviz pkgconfig python36 boost

+ git graphviz pkgconfig python3 python36 tcl-wrapper boost-libs

+ setup-x86_64.exe -q --packages=bison,flex,gcc-core,gcc-g++,git,libffi-devel,libreadline-devel,make,pkg-config,python3,tcl-devel,boost-build

+ also does not output blackbox modules on default. ``read_verilog``, unless

+ called with ``-noblackbox`` will automatically set the blackbox attribute

+ on any empty module it reads.

+- The ``noblackbox`` attribute set on an empty module prevents ``read_verilog``

+ from automatically setting the blackbox attribute on the module.

+

+- The ``whitebox`` attribute on modules triggers the same behavior as

+ ``blackbox``, but is for whitebox modules, i.e. library modules that

+ contain a behavioral model of the cell type.

+

+- The ``lib_whitebox`` attribute overwrites ``whitebox`` when ``read_verilog``

+ is run in `-lib` mode. Otherwise it's automatically removed.

+

+- The ``dynports`` attribute is used by the Verilog front-end to mark modules

+- The ``hdlname`` attribute is used by some passes to document the original

+ triple double quotes are removed from the macro body. For example:

+ explicit clock input (``$ff`` cells). The same can be achieved by using

+ always block: ``assert(<expression>);``. It is transformed to an ``$assert`` cell.

+ if (design->modules_.at(RTLIL::escape_id(cell_type))->get_blackbox_attribute())

+ if (module->get_blackbox_attribute()) {

+ if (module->get_blackbox_attribute() && !config.blackbox_mode)

+ if (cell->type.in("$ne", "$nex")) btor_op = "neq";

+ if (module->get_blackbox_attribute())

+ if (!design->modules_.count(cell->type) || design->modules_.at(cell->type)->get_blackbox_attribute()) {

+ if (module->get_blackbox_attribute())

+ if (module->get_blackbox_attribute())

+ if (module->get_blackbox_attribute() || module->has_memories_warn() || module->has_processes_warn())

+ if (!module->get_blackbox_attribute() && !module->has_memories_warn() && !module->has_processes_warn())

+ if (module->get_blackbox_attribute())

+ if (module->get_blackbox_attribute())

+ if (width == 0) {

+ f << "\"\"";

+ return;

+ }

+ if (GetSize(sig) == 0) {

+ f << "\"\"";

+ return;

+ }

+ if (it->second->get_blackbox_attribute() != blackboxes)

+out/**

+#!/usr/bin/python3

+

+from pyosys import libyosys as ys

+

+import matplotlib.pyplot as plt

+import numpy as np

+

+class CellStatsPass(ys.Pass):

+

+ def __init__(self):

+ super().__init__("cell_stats", "Shows cell stats as plot")

+

+ def py_help(self):

+ ys.log("This pass uses the matplotlib library to display cell stats\n")

+

+ def py_execute(self, args, design):

+ ys.log_header(design, "Plotting cell stats\n")

+ cell_stats = {}

+ for module in design.selected_whole_modules_warn():

+ for cell in module.selected_cells():

+ if cell.type.str() in cell_stats:

+ cell_stats[cell.type.str()] += 1

+ else:

+ cell_stats[cell.type.str()] = 1

+ plt.bar(range(len(cell_stats)), height = list(cell_stats.values()),align='center')

+ plt.xticks(range(len(cell_stats)), list(cell_stats.keys()))

+ plt.show()

+

+ def py_clear_flags(self):

+ ys.log("Clear Flags - CellStatsPass\n")

+

+p = CellStatsPass()

+#!/usr/bin/python3

+

+from pyosys import libyosys as ys

+

+import matplotlib.pyplot as plt

+import numpy as np

+

+design = ys.Design()

+ys.run_pass("read_verilog ../../tests/simple/fiedler-cooley.v", design);

+ys.run_pass("prep", design)

+ys.run_pass("opt -full", design)

+

+cell_stats = {}

+for module in design.selected_whole_modules_warn():

+ for cell in module.selected_cells():

+ if cell.type.str() in cell_stats:

+ cell_stats[cell.type.str()] += 1

+ else:

+ cell_stats[cell.type.str()] = 1

+plt.bar(range(len(cell_stats)), height = list(cell_stats.values()),align='center')

+plt.xticks(range(len(cell_stats)), list(cell_stats.keys()))

+plt.show()

+ bool flag_nomem2reg, flag_mem2reg, flag_noblackbox, flag_lib, flag_nowb, flag_noopt, flag_icells, flag_autowire;

+ bool blackbox_module = flag_lib;

+

+ if (!blackbox_module && !flag_noblackbox) {

+ blackbox_module = true;

+ for (auto child : ast->children) {

+ if (child->type == AST_WIRE && (child->is_input || child->is_output))

+ continue;

+ if (child->type == AST_PARAMETER || child->type == AST_LOCALPARAM)

+ continue;

+ blackbox_module = false;

+ break;

+ }

+ }

+

+ if (flag_nowb && ast->attributes.count("\\whitebox")) {

+ delete ast->attributes.at("\\whitebox");

+ ast->attributes.erase("\\whitebox");

+ }

+

+ if (ast->attributes.count("\\lib_whitebox")) {

+ if (!flag_lib || flag_nowb) {

+ delete ast->attributes.at("\\lib_whitebox");

+ ast->attributes.erase("\\lib_whitebox");

+ } else {

+ if (ast->attributes.count("\\whitebox")) {

+ delete ast->attributes.at("\\whitebox");

+ ast->attributes.erase("\\whitebox");

+ }

+ AstNode *n = ast->attributes.at("\\lib_whitebox");

+ ast->attributes["\\whitebox"] = n;

+ ast->attributes.erase("\\lib_whitebox");

+ }

+ }

+

+ if (!blackbox_module && ast->attributes.count("\\blackbox")) {

+ AstNode *n = ast->attributes.at("\\blackbox");

+ if (n->type != AST_CONSTANT)

+ log_file_error(ast->filename, ast->linenum, "Got blackbox attribute with non-constant value!\n");

+ blackbox_module = n->asBool();

+ }

+

+ if (blackbox_module && ast->attributes.count("\\whitebox")) {

+ AstNode *n = ast->attributes.at("\\whitebox");

+ if (n->type != AST_CONSTANT)

+ log_file_error(ast->filename, ast->linenum, "Got whitebox attribute with non-constant value!\n");

+ blackbox_module = !n->asBool();

+ }

+

+ if (ast->attributes.count("\\noblackbox")) {

+ if (blackbox_module) {

+ AstNode *n = ast->attributes.at("\\noblackbox");

+ if (n->type != AST_CONSTANT)

+ log_file_error(ast->filename, ast->linenum, "Got noblackbox attribute with non-constant value!\n");

+ blackbox_module = !n->asBool();

+ }

+ delete ast->attributes.at("\\noblackbox");

+ ast->attributes.erase("\\noblackbox");

+ }

+

+ if (blackbox_module)

+ {

+ if (ast->attributes.count("\\whitebox")) {

+ delete ast->attributes.at("\\whitebox");

+ ast->attributes.erase("\\whitebox");

+ }

+

+ if (ast->attributes.count("\\lib_whitebox")) {

+ delete ast->attributes.at("\\lib_whitebox");

+ ast->attributes.erase("\\lib_whitebox");

+ }

+

+

+

+ if (ast->attributes.count("\\blackbox") == 0) {

+ ast->attributes["\\blackbox"] = AstNode::mkconst_int(1, false);

+ }

+ current_module->noblackbox = flag_noblackbox;

+ current_module->nowb = flag_nowb;

+ bool nolatches, bool nomeminit, bool nomem2reg, bool mem2reg, bool noblackbox, bool lib, bool nowb, bool noopt, bool icells, bool nooverwrite, bool overwrite, bool defer, bool autowire)

+ flag_noblackbox = noblackbox;

+ flag_nowb = nowb;

+ flag_noblackbox = noblackbox;

+ flag_nowb = nowb;

+ bool nomem2reg, bool mem2reg, bool noblackbox, bool lib, bool nowb, bool noopt, bool icells, bool nooverwrite, bool overwrite, bool defer, bool autowire);

+ bool nolatches, nomeminit, nomem2reg, mem2reg, noblackbox, lib, nowb, noopt, icells, autowire;

+ {

+ AstNode *count = children[0];

+ AstNode *body = children[1];

+

+ // eval count expression

+ while (count->simplify(true, false, false, stage, 32, true, false)) { }

+

+ if (count->type != AST_CONSTANT)

+ log_file_error(filename, linenum, "Repeat loops outside must have constant repeat counts!\n");

+

+ // convert to a block with the body repeated n times

+ type = AST_BLOCK;

+ children.clear();

+ for (int i = 0; i < count->bitsAsConst().as_int(); i++)

+ children.insert(children.begin(), body->clone());

+

+ delete count;

+ delete body;

+ did_something = true;

+ }

+ {

+ int expr_width_hint = -1;

+ bool expr_sign_hint = true;

+ varbuf->detectSignWidth(expr_width_hint, expr_sign_hint);

+ while (varbuf->simplify(true, false, false, stage, 32, true, false)) { }

+ }

+ {

+ int expr_width_hint = -1;

+ bool expr_sign_hint = true;

+ buf->detectSignWidth(expr_width_hint, expr_sign_hint);

+ while (buf->simplify(true, false, false, stage, expr_width_hint, expr_sign_hint, false)) { }

+ }

+ {

+ int expr_width_hint = -1;

+ bool expr_sign_hint = true;

+ buf->detectSignWidth(expr_width_hint, expr_sign_hint);

+ while (buf->simplify(true, false, false, stage, expr_width_hint, expr_sign_hint, true)) { }

+ }

+#if 0

+ if (type == AST_FOR) {

+ AstNode *buf = next_ast->clone();

+ delete buf->children[1];

+ buf->children[1] = varbuf->children[0]->clone();

+ current_block->children.insert(current_block->children.begin() + current_block_idx++, buf);

+ }

+#endif

+

+ log(" -noblackbox\n");

+ log(" do not automatically add a (* blackbox *) attribute to an\n");

+ log(" empty module.\n");

+ log("\n");

+ log(" modules with the (* whitebox *) attribute will be preserved.\n");

+ log(" (* lib_whitebox *) will be treated like (* whitebox *).\n");

+ log("\n");

+ log(" -nowb\n");

+ log(" delete (* whitebox *) and (* lib_whitebox *) attributes from\n");

+ log(" all modules.\n");

+ noblackbox_mode = false;

+ nowb_mode = false;

+ if (arg == "-noblackbox") {

+ noblackbox_mode = true;

+ continue;

+ }

+ if (arg == "-nowb") {

+ nowb_mode = true;

+ continue;

+ }

+ log_header(design, "Executing Verilog-2005 frontend: %s\n", filename.c_str());

+

+ AST::process(design, current_ast, flag_dump_ast1, flag_dump_ast2, flag_no_dump_ptr, flag_dump_vlog1, flag_dump_vlog2, flag_dump_rtlil, flag_nolatches,

+ flag_nomeminit, flag_nomem2reg, flag_mem2reg, noblackbox_mode, lib_mode, nowb_mode, flag_noopt, flag_icells, flag_nooverwrite, flag_overwrite, flag_defer, default_nettype_wire);

+ // running in -noblackbox mode

+ extern bool noblackbox_mode;

+

+ // running in -nowb mode

+ extern bool nowb_mode;

+

+ bool sv_mode, formal_mode, noblackbox_mode, lib_mode, nowb_mode;

+ int Y = mk.nand_gate(mk.or_gate(A, B), mk.or_gate(C, D));

+ return eval_not(const_and(const_or(arg1, arg2, false, false, 1), const_or(arg3, arg4, false, false, 1), false, false, 1));

+inline int get_cell_cost(RTLIL::IdString type, const dict<RTLIL::IdString, RTLIL::Const> &parameters = dict<RTLIL::IdString, RTLIL::Const>(),

+inline int get_cell_cost(RTLIL::Cell *cell, dict<RTLIL::IdString, int> *mod_cost_cache)

+#ifdef WITH_PYTHON

+ PyRun_SimpleString(("sys.path.append(\""+proc_self_dirname()+"\")").c_str());

+ PyRun_SimpleString(("sys.path.append(\""+proc_share_dirname()+"plugins\")").c_str());

+#endif

+ printf(" -g\n");

+ printf(" globally enable debug log messages\n");

+ printf("\n");

+ while ((opt = getopt(argc, argv, "MXAQTVSgm:f:Hh:b:o:p:l:L:qv:tds:c:W:w:e:D:P:E:")) != -1)

+ case 'g':

+ log_force_debug++;

+ break;

+#ifdef WITH_PYTHON

+ PyRun_SimpleString(("sys.path.append(\""+proc_self_dirname()+"\")").c_str());

+ PyRun_SimpleString(("sys.path.append(\""+proc_share_dirname()+"plugins\")").c_str());

+#endif

+ fprintf(f, "%s%s", first ? "" : " ", escape_filename_spaces(fn).c_str());

+ fprintf(f, " %s", escape_filename_spaces(fn).c_str());

+int log_make_debug = 0;

+int log_force_debug = 0;

+int log_debug_suppressed = 0;

+

+ if (log_make_debug && !ys_debug(1))

+ return;

+

+extern int log_make_debug;

+extern int log_force_debug;

+extern int log_debug_suppressed;

+

+#ifndef NDEBUG

+static inline bool ys_debug(int n = 0) { if (log_force_debug) return true; log_debug_suppressed += n; return false; }

+# define log_debug(...) do { if (ys_debug(1)) log(__VA_ARGS__); } while (0)

+#else

+static inline bool ys_debug(int n = 0) { return false; }

+# define log_debug(_fmt, ...) do { } while (0)

+#endif

+

+static inline void log_suppressed() {

+ if (log_debug_suppressed && !log_make_debug) {

+ log("<suppressed ~%d debug messages>\n", log_debug_suppressed);

+ log_debug_suppressed = 0;

+ }

+}

+

+struct LogMakeDebugHdl {

+ bool status = false;

+ LogMakeDebugHdl(bool start_on = false) {

+ if (start_on)

+ on();

+ }

+ ~LogMakeDebugHdl() {

+ off();

+ }

+ void on() {

+ if (status) return;

+ status=true;

+ log_make_debug++;

+ }

+ void off_silent() {

+ if (!status) return;

+ status=false;

+ log_make_debug--;

+ }

+ void off() {

+ off_silent();

+ }

+};

+

+ log_suppressed();

+RTLIL::Const::Const(const RTLIL::Const &c)

+{

+ flags = c.flags;

+ for (auto b : c.bits)

+ this->bits.push_back(b);

+}

+

+void RTLIL::AttrObject::set_bool_attribute(RTLIL::IdString id, bool value)

+ if (value)

+ attributes[id] = RTLIL::Const(1);

+ else if (attributes.count(id))

+ attributes.erase(id);

+

+#ifdef WITH_PYTHON

+ RTLIL::Design::get_all_designs()->insert(std::pair<unsigned int, RTLIL::Design*>(hashidx_, this));

+#endif

+#ifdef WITH_PYTHON

+ RTLIL::Design::get_all_designs()->erase(hashidx_);

+#endif

+#ifdef WITH_PYTHON

+static std::map<unsigned int, RTLIL::Design*> all_designs;

+std::map<unsigned int, RTLIL::Design*> *RTLIL::Design::get_all_designs(void)

+{

+ return &all_designs;

+}

+#endif

+

+ if (selected_module(it.first) && !it.second->get_blackbox_attribute())

+ if (selected_whole_module(it.first) && !it.second->get_blackbox_attribute())

+ if (it.second->get_blackbox_attribute())

+

+#ifdef WITH_PYTHON

+ RTLIL::Module::get_all_modules()->insert(std::pair<unsigned int, RTLIL::Module*>(hashidx_, this));

+#endif

+#ifdef WITH_PYTHON

+ RTLIL::Module::get_all_modules()->erase(hashidx_);

+#endif

+}

+

+#ifdef WITH_PYTHON

+static std::map<unsigned int, RTLIL::Module*> all_modules;

+std::map<unsigned int, RTLIL::Module*> *RTLIL::Module::get_all_modules(void)

+{

+ return &all_modules;

+#endif

+

+#ifdef WITH_PYTHON

+ RTLIL::Wire::get_all_wires()->insert(std::pair<unsigned int, RTLIL::Wire*>(hashidx_, this));

+#endif

+}

+

+RTLIL::Wire::~Wire()

+{

+#ifdef WITH_PYTHON

+ RTLIL::Wire::get_all_wires()->erase(hashidx_);

+#endif

+}

+

+#ifdef WITH_PYTHON

+static std::map<unsigned int, RTLIL::Wire*> all_wires;

+std::map<unsigned int, RTLIL::Wire*> *RTLIL::Wire::get_all_wires(void)

+{

+ return &all_wires;

+#endif

+#ifdef WITH_PYTHON

+ RTLIL::Memory::get_all_memorys()->insert(std::pair<unsigned int, RTLIL::Memory*>(hashidx_, this));

+#endif

+

+#ifdef WITH_PYTHON

+ RTLIL::Cell::get_all_cells()->insert(std::pair<unsigned int, RTLIL::Cell*>(hashidx_, this));

+#endif

+}

+

+RTLIL::Cell::~Cell()

+{

+#ifdef WITH_PYTHON

+ RTLIL::Cell::get_all_cells()->erase(hashidx_);

+#endif

+}

+

+#ifdef WITH_PYTHON

+static std::map<unsigned int, RTLIL::Cell*> all_cells;

+std::map<unsigned int, RTLIL::Cell*> *RTLIL::Cell::get_all_cells(void)

+{

+ return &all_cells;

+#endif

+RTLIL::SigChunk::SigChunk(const RTLIL::SigChunk &sigchunk) : data(sigchunk.data)

+{

+ wire = sigchunk.wire;

+ data = sigchunk.data;

+ width = sigchunk.width;

+ offset = sigchunk.offset;

+}

+

+ if (chunks_.size() != other.chunks_.size())

+#ifdef WITH_PYTHON

+RTLIL::Memory::~Memory()

+{

+ RTLIL::Memory::get_all_memorys()->erase(hashidx_);

+}

+static std::map<unsigned int, RTLIL::Memory*> all_memorys;

+std::map<unsigned int, RTLIL::Memory*> *RTLIL::Memory::get_all_memorys(void)

+{

+ return &all_memorys;

+}

+#endif

+ Const(const RTLIL::Const &c);

+ void set_bool_attribute(RTLIL::IdString id, bool value=true);

+ bool get_blackbox_attribute(bool ignore_wb=false) const {

+ return get_bool_attribute("\\blackbox") || (!ignore_wb && get_bool_attribute("\\whitebox"));

+ }

+

+ SigChunk(const RTLIL::SigChunk &sigchunk);

+ SigBit(const RTLIL::SigBit &sigbit);

+

+#ifdef WITH_PYTHON

+ static std::map<unsigned int, RTLIL::Design*> *get_all_designs(void);

+#endif

+

+#ifdef WITH_PYTHON

+ static std::map<unsigned int, RTLIL::Module*> *get_all_modules(void);

+#endif

+ ~Wire();

+

+#ifdef WITH_PYTHON

+ static std::map<unsigned int, RTLIL::Wire*> *get_all_wires(void);

+#endif

+#ifdef WITH_PYTHON

+ ~Memory();

+ static std::map<unsigned int, RTLIL::Memory*> *get_all_memorys(void);

+#endif

+ ~Cell();

+

+#ifdef WITH_PYTHON

+ static std::map<unsigned int, RTLIL::Cell*> *get_all_cells(void);

+#endif

+inline RTLIL::SigBit::SigBit(const RTLIL::SigBit &sigbit) : wire(sigbit.wire), data(sigbit.data){if(wire) offset = sigbit.offset;}

+#ifdef WITH_PYTHON

+#if PY_MAJOR_VERSION >= 3

+# define INIT_MODULE PyInit_libyosys

+ extern "C" PyObject* INIT_MODULE();

+#else

+# define INIT_MODULE initlibyosys

+ extern "C" void INIT_MODULE();

+#endif

+#endif

+

+std::string escape_filename_spaces(const std::string& filename)

+{

+ std::string out;

+ out.reserve(filename.size());

+ for (auto c : filename)

+ {

+ if (c == ' ')

+ out += "\\ ";

+ else

+ out.push_back(c);

+ }

+ return out;

+}

+

+bool already_setup = false;

+

+ if(already_setup)

+ return;

+ already_setup = true;

+ #ifdef WITH_PYTHON

+ PyImport_AppendInittab((char*)"libyosys", INIT_MODULE);

+ Py_Initialize();

+ PyRun_SimpleString("import sys");

+ #endif

+

+bool yosys_already_setup()

+{

+ return already_setup;

+}

+

+bool already_shutdown = false;

+

+ if(already_shutdown)

+ return;

+ already_shutdown = true;

+#ifdef WITH_PYTHON

+ loaded_python_plugins.clear();

+#endif

+#ifdef WITH_PYTHON

+ Py_Finalize();

+#endif

+

+#ifdef WITH_PYTHON

+#include <Python.h>

+#endif

+

+#define YOSYS_NAMESPACE Yosys

+std::string escape_filename_spaces(const std::string& filename);

+

+#ifdef WITH_PYTHON

+bool yosys_already_setup();

+#endif

+

+#ifdef WITH_PYTHON

+extern std::map<std::string, void*> loaded_python_plugins;

+#endif

+import os

+import sys

+sys.setdlopenflags(os.RTLD_NOW | os.RTLD_GLOBAL)

+

+__all__ = ["libyosys"]

+#

+# yosys -- Yosys Open SYnthesis Suite

+#

+# Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>

+#

+# 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.

+#

+# Author Benedikt Tutzer

+#

+

+import copy

+

+#Map c++ operator Syntax to Python functions

+wrappable_operators = {

+ "<" : "__lt__",

+ "==": "__eq__",

+ "!=": "__ne__",

+ "+" : "__add__",

+ "-" : "__sub__",

+ "*" : "__mul__",

+ "/" : "__div__",

+ "()": "__call__"

+ }

+

+#Restrict certain strings from being function names in Python

+keyword_aliases = {

+ "in" : "in_",

+ "False" : "False_",

+ "None" : "None_",

+ "True" : "True_",

+ "and" : "and_",

+ "as" : "as_",

+ "assert" : "assert_",

+ "break" : "break_",

+ "class" : "class_",

+ "continue" : "continue_",

+ "def" : "def_",

+ "del" : "del_",

+ "elif" : "elif_",

+ "else" : "else_",

+ "except" : "except_",

+ "for" : "for_",

+ "from" : "from_",

+ "global" : "global_",

+ "if" : "if_",

+ "import" : "import_",

+ "in" : "in_",

+ "is" : "is_",

+ "lambda" : "lambda_",

+ "nonlocal" : "nonlocal_",

+ "not" : "not_",

+ "or" : "or_",

+ "pass" : "pass_",

+ "raise" : "raise_",

+ "return" : "return_",

+ "try" : "try_",

+ "while" : "while_",

+ "with" : "with_",

+ "yield" : "yield_"

+ }

+

+#These can be used without any explicit conversion

+primitive_types = ["void", "bool", "int", "double", "size_t", "std::string",

+ "string", "State", "char_p"]

+

+from enum import Enum

+

+#Ways to link between Python- and C++ Objects

+class link_types(Enum):

+ global_list = 1 #Manage a global list of objects in C++, the Python

+ #object contains a key to find the corresponding C++

+ #object and a Pointer to the object to verify it is

+ #still the same, making collisions unlikely to happen

+ ref_copy = 2 #The Python object contains a copy of the C++ object.

+ #The C++ object is deleted when the Python object gets

+ #deleted

+ pointer = 3 #The Python Object contains a pointer to it's C++

+ #counterpart

+ derive = 4 #The Python-Wrapper is derived from the C++ object.

+

+class attr_types(Enum):

+ star = "*"

+ amp = "&"

+ ampamp = "&&"

+ default = ""

+

+#For source-files

+class Source:

+ name = ""

+ classes = []

+

+ def __init__(self, name, classes):

+ self.name = name

+ self.classes = classes

+

+#Splits a list by the given delimiter, without splitting strings inside

+#pointy-brackets (< and >)

+def split_list(str_def, delim):

+ str_def = str_def.strip()

+ if len(str_def) == 0:

+ return []

+ if str_def.count(delim) == 0:

+ return [str_def]

+ if str_def.count("<") == 0:

+ return str_def.split(delim)

+ if str_def.find("<") < str_def.find(" "):

+ closing = find_closing(str_def[str_def.find("<")+1:], "<", ">") + str_def.find("<")

+ comma = str_def[closing:].find(delim)

+ if comma == -1:

+ return [str_def]

+ comma = closing + comma

+ else:

+ comma = str_def.find(delim)

+ rest = split_list(str_def[comma+1:], delim)

+ ret = [str_def[:comma]]

+ if rest != None and len(rest) != 0:

+ ret.extend(rest)

+ return ret

+

+#Represents a Type

+class WType:

+ name = ""

+ cont = None

+ attr_type = attr_types.default

+

+ def __init__(self, name = "", cont = None, attr_type = attr_types.default):

+ self.name = name

+ self.cont = cont

+ self.attr_type = attr_type

+

+ #Python type-string

+ def gen_text(self):

+ text = self.name

+ if self.name in enum_names:

+ text = enum_by_name(self.name).namespace + "::" + self.name

+ if self.cont != None:

+ return known_containers[self.name].typename

+ return text

+

+ #C++ type-string

+ def gen_text_cpp(self):

+ postfix = ""

+ if self.attr_type == attr_types.star:

+ postfix = "*"

+ if self.name in primitive_types:

+ return self.name + postfix

+ if self.name in enum_names:

+ return enum_by_name(self.name).namespace + "::" + self.name + postfix

+ if self.name in classnames:

+ return class_by_name(self.name).namespace + "::" + self.name + postfix

+ text = self.name

+ if self.cont != None:

+ text += "<"

+ for a in self.cont.args:

+ text += a.gen_text_cpp() + ", "

+ text = text[:-2]

+ text += ">"

+ return text

+

+ @staticmethod

+ def from_string(str_def, containing_file, line_number):

+ str_def = str_def.strip()

+ if len(str_def) == 0:

+ return None

+ str_def = str_def.replace("RTLIL::SigSig", "std::pair<SigSpec, SigSpec>").replace("SigSig", "std::pair<SigSpec, SigSpec>")

+ t = WType()

+ t.name = ""

+ t.cont = None

+ t.attr_type = attr_types.default

+ if str_def.find("<") != -1:# and str_def.find("<") < str_def.find(" "):

+ candidate = WContainer.from_string(str_def, containing_file, line_number)

+ if candidate == None:

+ return None

+ t.name = str_def[:str_def.find("<")]

+

+ if t.name.count("*") + t.name.count("&") > 1:

+ return None

+

+ if t.name.count("*") == 1 or str_def[0] == '*' or str_def[-1] == '*':

+ t.attr_type = attr_types.star

+ t.name = t.name.replace("*","")

+ elif t.name.count("&&") == 1:

+ t.attr_type = attr_types.ampamp

+ t.name = t.name.replace("&&","")

+ elif t.name.count("&") == 1 or str_def[0] == '&' or str_def[-1] == '&':

+ t.attr_type = attr_types.amp

+ t.name = t.name.replace("&","")

+

+ t.cont = candidate

+ if(t.name not in known_containers):

+ return None

+ return t

+

+ prefix = ""

+

+ if str.startswith(str_def, "unsigned "):

+ prefix = "unsigned "

+ str_def = str_def[9:]

+ while str.startswith(str_def, "long "):

+ prefix= "long " + prefix

+ str_def = str_def[5:]

+ while str.startswith(str_def, "short "):

+ prefix = "short " + prefix

+ str_def = str_def[6:]

+

+ str_def = str_def.split("::")[-1]

+

+ if str_def.count("*") + str_def.count("&") >= 2:

+ return None

+

+ if str_def.count("*") == 1:

+ t.attr_type = attr_types.star

+ str_def = str_def.replace("*","")

+ elif str_def.count("&&") == 1:

+ t.attr_type = attr_types.ampamp

+ str_def = str_def.replace("&&","")

+ elif str_def.count("&") == 1:

+ t.attr_type = attr_types.amp

+ str_def = str_def.replace("&","")

+

+ if len(str_def) > 0 and str_def.split("::")[-1] not in primitive_types and str_def.split("::")[-1] not in classnames and str_def.split("::")[-1] not in enum_names:

+ return None

+

+ if str_def.count(" ") == 0:

+ t.name = (prefix + str_def).replace("char_p", "char *")

+ t.cont = None

+ return t

+ return None

+

+#Represents a container-type

+class WContainer:

+ name = ""

+ args = []

+

+ def from_string(str_def, containing_file, line_number):

+ if str_def == None or len(str_def) < 4:

+ return None

+ cont = WContainer()

+ cont.name = str_def[:str_def.find("<")]

+ str_def = str_def[str_def.find("<")+1:find_closing(str_def, "<", ">")]

+ cont.args = []

+ for arg in split_list(str_def, ","):

+ candidate = WType.from_string(arg.strip(), containing_file, line_number)

+ if candidate == None:

+ return None

+ cont.args.append(candidate)

+ return cont

+

+#Translators between Python and C++ containers

+#Base Type

+class Translator:

+ tmp_cntr = 0

+ typename = "DefaultType"

+ orig_name = "DefaultCpp"

+

+ @classmethod

+ def gen_type(c, types):

+ return "\nImplement a function that outputs the c++ type of this container here\n"

+

+ @classmethod

+ def translate(c, varname, types, prefix):

+ return "\nImplement a function translating a python container to a c++ container here\n"

+

+ @classmethod

+ def translate_cpp(c, varname, types, prefix, ref):

+ return "\nImplement a function translating a c++ container to a python container here\n"

+

+#Translates list-types (vector, pool, set), that only differ in their name and

+#the name of the insertion function

+class PythonListTranslator(Translator):

+ typename = "boost::python::list"

+ insert_name = "Default"

+

+ #generate the c++ type string

+ @classmethod

+ def gen_type(c, types):

+ text = c.orig_name + "<"

+ if types[0].name in primitive_types:

+ text += types[0].name

+ elif types[0].name in known_containers:

+ text += known_containers[types[0].name].gen_type(types[0].cont.args)

+ else:

+ text += class_by_name(types[0].name).namespace + "::" + types[0].name

+ if types[0].attr_type == attr_types.star:

+ text += "*"

+ text += ">"

+ return text

+

+ #Generate C++ code to translate from a boost::python::list

+ @classmethod

+ def translate(c, varname, types, prefix):

+ text = prefix + c.gen_type(types) + " " + varname + "___tmp;"

+ cntr_name = "cntr_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ text += prefix + "for(int " + cntr_name + " = 0; " + cntr_name + " < len(" + varname + "); " + cntr_name + "++)"

+ text += prefix + "{"

+ tmp_name = "tmp_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ if types[0].name in known_containers:

+ text += prefix + "\t" + known_containers[types[0].name].typename + " " + tmp_name + " = boost::python::extract<" + known_containers[types[0].name].typename + ">(" + varname + "[" + cntr_name + "]);"

+ text += known_containers[types[0].name].translate(tmp_name, types[0].cont.args, prefix+"\t")

+ tmp_name = tmp_name + "___tmp"

+ text += prefix + "\t" + varname + "___tmp." + c.insert_name + "(" + tmp_name + ");"

+ elif types[0].name in classnames:

+ text += prefix + "\t" + types[0].name + "* " + tmp_name + " = boost::python::extract<" + types[0].name + "*>(" + varname + "[" + cntr_name + "]);"

+ if types[0].attr_type == attr_types.star:

+ text += prefix + "\t" + varname + "___tmp." + c.insert_name + "(" + tmp_name + "->get_cpp_obj());"

+ else:

+ text += prefix + "\t" + varname + "___tmp." + c.insert_name + "(*" + tmp_name + "->get_cpp_obj());"

+ else:

+ text += prefix + "\t" + types[0].name + " " + tmp_name + " = boost::python::extract<" + types[0].name + ">(" + varname + "[" + cntr_name + "]);"

+ text += prefix + "\t" + varname + "___tmp." + c.insert_name + "(" + tmp_name + ");"

+ text += prefix + "}"

+ return text

+

+ #Generate C++ code to translate to a boost::python::list

+ @classmethod

+ def translate_cpp(c, varname, types, prefix, ref):

+ text = prefix + c.typename + " " + varname + "___tmp;"

+ tmp_name = "tmp_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ if ref:

+ text += prefix + "for(auto " + tmp_name + " : *" + varname + ")"

+ else:

+ text += prefix + "for(auto " + tmp_name + " : " + varname + ")"

+ text += prefix + "{"

+ if types[0].name in classnames:

+ if types[0].attr_type == attr_types.star:

+ text += prefix + "\t" + varname + "___tmp.append(" + types[0].name + "::get_py_obj(" + tmp_name + "));"

+ else:

+ text += prefix + "\t" + varname + "___tmp.append(*" + types[0].name + "::get_py_obj(&" + tmp_name + "));"

+ elif types[0].name in known_containers:

+ text += known_containers[types[0].name].translate_cpp(tmp_name, types[0].cont.args, prefix + "\t", types[0].attr_type == attr_types.star)

+ text += prefix + "\t" + varname + "___tmp.append(" + tmp_name + "___tmp);"

+ else:

+ text += prefix + "\t" + varname + "___tmp.append(" + tmp_name + ");"

+ text += prefix + "}"

+ return text

+

+#Sub-type for std::set

+class SetTranslator(PythonListTranslator):

+ insert_name = "insert"

+ orig_name = "std::set"

+

+#Sub-type for std::vector

+class VectorTranslator(PythonListTranslator):

+ insert_name = "push_back"

+ orig_name = "std::vector"

+

+#Sub-type for pool

+class PoolTranslator(PythonListTranslator):

+ insert_name = "insert"

+ orig_name = "pool"

+

+#Translates dict-types (dict, std::map), that only differ in their name and

+#the name of the insertion function

+class PythonDictTranslator(Translator):

+ typename = "boost::python::dict"

+ insert_name = "Default"

+

+ @classmethod

+ def gen_type(c, types):

+ text = c.orig_name + "<"

+ if types[0].name in primitive_types:

+ text += types[0].name

+ elif types[0].name in known_containers:

+ text += known_containers[types[0].name].gen_type(types[0].cont.args)

+ else:

+ text += class_by_name(types[0].name).namespace + "::" + types[0].name

+ if types[0].attr_type == attr_types.star:

+ text += "*"

+ text += ", "

+ if types[1].name in primitive_types:

+ text += types[1].name

+ elif types[1].name in known_containers:

+ text += known_containers[types[1].name].gen_type(types[1].cont.args)

+ else:

+ text += class_by_name(types[1].name).namespace + "::" + types[1].name

+ if types[1].attr_type == attr_types.star:

+ text += "*"

+ text += ">"

+ return text

+

+ #Generate c++ code to translate from a boost::python::dict

+ @classmethod

+ def translate(c, varname, types, prefix):

+ text = prefix + c.gen_type(types) + " " + varname + "___tmp;"

+ text += prefix + "boost::python::list " + varname + "_keylist = " + varname + ".keys();"

+ cntr_name = "cntr_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ text += prefix + "for(int " + cntr_name + " = 0; " + cntr_name + " < len(" + varname + "_keylist); " + cntr_name + "++)"

+ text += prefix + "{"

+ key_tmp_name = "key_tmp_" + str(Translator.tmp_cntr)

+ val_tmp_name = "val_tmp_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+

+ if types[0].name in known_containers:

+ text += prefix + "\t" + known_containers[types[0].name].typename + " " + key_tmp_name + " = boost::python::extract<" + known_containers[types[0].name].typename + ">(" + varname + "_keylist[ " + cntr_name + " ]);"

+ text += known_containers[types[0].name].translate(key_tmp_name, types[0].cont.args, prefix+"\t")

+ key_tmp_name = key_tmp_name + "___tmp"

+ elif types[0].name in classnames:

+ text += prefix + "\t" + types[0].name + "* " + key_tmp_name + " = boost::python::extract<" + types[0].name + "*>(" + varname + "_keylist[ " + cntr_name + " ]);"

+ else:

+ text += prefix + "\t" + types[0].name + " " + key_tmp_name + " = boost::python::extract<" + types[0].name + ">(" + varname + "_keylist[ " + cntr_name + " ]);"

+

+ if types[1].name in known_containers:

+ text += prefix + "\t" + known_containers[types[1].name].typename + " " + val_tmp_name + " = boost::python::extract<" + known_containers[types[1].name].typename + ">(" + varname + "[" + varname + "_keylist[ " + cntr_name + " ]]);"

+ text += known_containers[types[1].name].translate(val_tmp_name, types[1].cont.args, prefix+"\t")

+ val_tmp_name = val_tmp_name + "___tmp"

+ elif types[1].name in classnames:

+ text += prefix + "\t" + types[1].name + "* " + val_tmp_name + " = boost::python::extract<" + types[1].name + "*>(" + varname + "[" + varname + "_keylist[ " + cntr_name + " ]]);"

+ else:

+ text += prefix + "\t" + types[1].name + " " + val_tmp_name + " = boost::python::extract<" + types[1].name + ">(" + varname + "[" + varname + "_keylist[ " + cntr_name + " ]]);"

+

+ text += prefix + "\t" + varname + "___tmp." + c.insert_name + "(std::pair<" + types[0].gen_text_cpp() + ", " + types[1].gen_text_cpp() + ">("

+

+ if types[0].name not in classnames:

+ text += key_tmp_name

+ else:

+ if types[0].attr_type != attr_types.star:

+ text += "*"

+ text += key_tmp_name + "->get_cpp_obj()"

+

+ text += ", "

+ if types[1].name not in classnames:

+ text += val_tmp_name

+ else:

+ if types[1].attr_type != attr_types.star:

+ text += "*"

+ text += val_tmp_name + "->get_cpp_obj()"

+ text += "));\n" + prefix + "}"

+ return text

+

+ #Generate c++ code to translate to a boost::python::dict

+ @classmethod

+ def translate_cpp(c, varname, types, prefix, ref):

+ text = prefix + c.typename + " " + varname + "___tmp;"

+ tmp_name = "tmp_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ if ref:

+ text += prefix + "for(auto " + tmp_name + " : *" + varname + ")"

+ else:

+ text += prefix + "for(auto " + tmp_name + " : " + varname + ")"

+ text += prefix + "{"

+ if types[1].name in known_containers:

+ text += prefix + "\tauto " + tmp_name + "_second = " + tmp_name + ".second;"

+ text += known_containers[types[1].name].translate_cpp(tmp_name + "_second", types[1].cont.args, prefix + "\t", types[1].attr_type == attr_types.star)

+

+ if types[0].name in classnames:

+ text += prefix + "\t" + varname + "___tmp[" + types[0].name + "::get_py_obj(" + tmp_name + ".first)] = "

+ elif types[0].name not in known_containers:

+ text += prefix + "\t" + varname + "___tmp[" + tmp_name + ".first] = "

+

+ if types[1].name in classnames:

+ if types[1].attr_type == attr_types.star:

+ text += types[1].name + "::get_py_obj(" + tmp_name + ".second);"

+ else:

+ text += "*" + types[1].name + "::get_py_obj(&" + tmp_name + ".second);"

+ elif types[1].name in known_containers:

+ text += tmp_name + "_second___tmp;"

+ else:

+ text += tmp_name + ".second;"

+ text += prefix + "}"

+ return text

+

+#Sub-type for dict

+class DictTranslator(PythonDictTranslator):

+ insert_name = "insert"

+ orig_name = "dict"

+

+#Sub_type for std::map

+class MapTranslator(PythonDictTranslator):

+ insert_name = "insert"

+ orig_name = "std::map"

+

+#Translator for std::pair. Derived from PythonDictTranslator because the

+#gen_type function is the same (because both have two template parameters)

+class TupleTranslator(PythonDictTranslator):

+ typename = "boost::python::tuple"

+ orig_name = "std::pair"

+

+ #Generate c++ code to translate from a boost::python::tuple

+ @classmethod

+ def translate(c, varname, types, prefix):

+ text = prefix + types[0].name + " " + varname + "___tmp_0 = boost::python::extract<" + types[0].name + ">(" + varname + "[0]);"

+ text += prefix + types[1].name + " " + varname + "___tmp_1 = boost::python::extract<" + types[1].name + ">(" + varname + "[1]);"

+ text += prefix + TupleTranslator.gen_type(types) + " " + varname + "___tmp("

+ if types[0].name.split(" ")[-1] in primitive_types:

+ text += varname + "___tmp_0, "

+ else:

+ text += varname + "___tmp_0.get_cpp_obj(), "

+ if types[1].name.split(" ")[-1] in primitive_types:

+ text += varname + "___tmp_1);"

+ else:

+ text += varname + "___tmp_1.get_cpp_obj());"

+ return text

+

+ #Generate c++ code to translate to a boost::python::tuple

+ @classmethod

+ def translate_cpp(c, varname, types, prefix, ref):

+ text = prefix + TupleTranslator.typename + " " + varname + "___tmp = boost::python::make_tuple(" + varname + ".first, " + varname + ".second);"

+ return text

+ tmp_name = "tmp_" + str(Translator.tmp_cntr)

+ Translator.tmp_cntr = Translator.tmp_cntr + 1

+ if ref:

+ text += prefix + "for(auto " + tmp_name + " : *" + varname + ")"

+ else:

+ text += prefix + "for(auto " + tmp_name + " : " + varname + ")"

+ text += prefix + "{"

+ if types[0].name.split(" ")[-1] in primitive_types or types[0].name in enum_names:

+ text += prefix + "\t" + varname + "___tmp.append(" + tmp_name + ");"

+ elif types[0].name in known_containers:

+ text += known_containers[types[0].name].translate_cpp(tmp_name, types[0].cont.args, prefix + "\t", types[1].attr_type == attr_types.star)

+ text += prefix + "\t" + varname + "___tmp.append(" + types[0].name + "::get_py_obj(" + tmp_name + "___tmp);"

+ elif types[0].name in classnames:

+ text += prefix + "\t" + varname + "___tmp.append(" + types[0].name + "::get_py_obj(" + tmp_name + "));"

+ text += prefix + "}"

+ return text

+

+#Associate the Translators with their c++ type

+known_containers = {

+ "std::set" : SetTranslator,

+ "std::vector" : VectorTranslator,

+ "pool" : PoolTranslator,

+ "dict" : DictTranslator,

+ "std::pair" : TupleTranslator,

+ "std::map" : MapTranslator

+}

+

+class Attribute:

+ wtype = None

+ varname = None

+ is_const = False

+ default_value = None

+ pos = None

+ pos_counter = 0

+

+ def __init__(self, wtype, varname, is_const = False, default_value = None):

+ self.wtype = wtype

+ self.varname = varname

+ self.is_const = is_const

+ self.default_value = None

+ self.container = None

+

+ @staticmethod

+ def from_string(str_def, containing_file, line_number):

+ if len(str_def) < 3:

+ return None

+ orig = str_def

+ arg = Attribute(None, None)

+ prefix = ""

+ arg.wtype = None

+ arg.varname = None

+ arg.is_const = False

+ arg.default_value = None

+ arg.container = None

+ if str.startswith(str_def, "const "):

+ arg.is_const = True

+ str_def = str_def[6:]

+ if str.startswith(str_def, "unsigned "):

+ prefix = "unsigned "

+ str_def = str_def[9:]

+ while str.startswith(str_def, "long "):

+ prefix= "long " + prefix

+ str_def = str_def[5:]

+ while str.startswith(str_def, "short "):

+ prefix = "short " + prefix

+ str_def = str_def[6:]

+

+ if str_def.find("<") != -1 and str_def.find("<") < str_def.find(" "):

+ closing = find_closing(str_def[str_def.find("<"):], "<", ">") + str_def.find("<") + 1

+ arg.wtype = WType.from_string(str_def[:closing].strip(), containing_file, line_number)

+ str_def = str_def[closing+1:]

+ else:

+ if str_def.count(" ") > 0:

+ arg.wtype = WType.from_string(prefix + str_def[:str_def.find(" ")].strip(), containing_file, line_number)

+ str_def = str_def[str_def.find(" ")+1:]

+ else:

+ arg.wtype = WType.from_string(prefix + str_def.strip(), containing_file, line_number)

+ str_def = ""

+ arg.varname = ""

+

+ if arg.wtype == None:

+ return None

+ if str_def.count("=") == 0:

+ arg.varname = str_def.strip()

+ if arg.varname.find(" ") > 0:

+ return None

+ else:

+ arg.varname = str_def[:str_def.find("=")].strip()

+ if arg.varname.find(" ") > 0:

+ return None

+ str_def = str_def[str_def.find("=")+1:].strip()

+ arg.default_value = str_def[arg.varname.find("=")+1:].strip()

+ if len(arg.varname) == 0:

+ arg.varname = None

+ return arg

+ if arg.varname[0] == '*':

+ arg.wtype.attr_type = attr_types.star

+ arg.varname = arg.varname[1:]

+ elif arg.varname[0] == '&':

+ if arg.wtype.attr_type != attr_types.default:

+ return None

+ if arg.varname[1] == '&':

+ arg.wtype.attr_type = attr_types.ampamp

+ arg.varname = arg.varname[2:]

+ else:

+ arg.wtype.attr_type = attr_types.amp

+ arg.varname = arg.varname[1:]

+ return arg

+

+ #Generates the varname. If the attribute has no name in the header file,

+ #a name is generated

+ def gen_varname(self):

+ if self.varname != None:

+ return self.varname

+ if self.wtype.name == "void":

+ return ""

+ if self.pos == None:

+ self.pos = Attribute.pos_counter

+ Attribute.pos_counter = Attribute.pos_counter + 1

+ return "gen_varname_" + str(self.pos)

+

+ #Generates the text for the function headers with wrapper types

+ def gen_listitem(self):

+ prefix = ""

+ if self.is_const:

+ prefix = "const "

+ if self.wtype.name in classnames:

+ return prefix + self.wtype.name + "* " + self.gen_varname()

+ if self.wtype.name in known_containers:

+ return prefix + known_containers[self.wtype.name].typename + " " + self.gen_varname()

+ return prefix + self.wtype.name + " " + self.gen_varname()

+

+ #Generates the test for the function headers with c++ types

+ def gen_listitem_cpp(self):

+ prefix = ""

+ if self.is_const:

+ prefix = "const "

+ infix = ""

+ if self.wtype.attr_type == attr_types.star:

+ infix = "*"

+ elif self.wtype.attr_type == attr_types.amp:

+ infix = "&"

+ elif self.wtype.attr_type == attr_types.ampamp:

+ infix = "&&"

+ if self.wtype.name in known_containers:

+ return prefix + known_containers[self.wtype.name].gen_type(self.wtype.cont.args) + " " + infix + self.gen_varname()

+ if self.wtype.name in classnames:

+ return prefix + class_by_name(self.wtype.name).namespace + "::" + self.wtype.name + " " + infix + self.gen_varname()

+ return prefix + self.wtype.name + " " + infix + self.gen_varname()

+

+ #Generates the listitem withtout the varname, so the signature can be

+ #compared

+ def gen_listitem_hash(self):

+ prefix = ""

+ if self.is_const:

+ prefix = "const "

+ if self.wtype.name in classnames:

+ return prefix + self.wtype.name + "* "

+ if self.wtype.name in known_containers:

+ return known_containers[self.wtype.name].typename

+ return prefix + self.wtype.name

+

+ #Generate Translation code for the attribute

+ def gen_translation(self):

+ if self.wtype.name in known_containers:

+ return known_containers[self.wtype.name].translate(self.gen_varname(), self.wtype.cont.args, "\n\t\t")

+ return ""

+

+ #Generate Translation code from c++ for the attribute

+ def gen_translation_cpp(self):

+ if self.wtype.name in known_containers:

+ return known_containers[self.wtype.name].translate_cpp(self.gen_varname(), self.wtype.cont.args, "\n\t\t", self.wtype.attr_type == attr_types.star)

+ return ""

+

+ #Generate Text for the call

+ def gen_call(self):

+ ret = self.gen_varname()

+ if self.wtype.name in known_containers:

+ if self.wtype.attr_type == attr_types.star:

+ return "&" + ret + "___tmp"

+ return ret + "___tmp"

+ if self.wtype.name in classnames:

+ if self.wtype.attr_type != attr_types.star:

+ ret = "*" + ret

+ return ret + "->get_cpp_obj()"

+ if self.wtype.name == "char *" and self.gen_varname() in ["format", "fmt"]:

+ return "\"%s\", " + self.gen_varname()

+ if self.wtype.attr_type == attr_types.star:

+ return "&" + ret

+ return ret

+

+ def gen_call_cpp(self):

+ ret = self.gen_varname()

+ if self.wtype.name.split(" ")[-1] in primitive_types or self.wtype.name in enum_names:

+ if self.wtype.attr_type == attr_types.star:

+ return "&" + ret

+ return ret

+ if self.wtype.name not in classnames:

+ if self.wtype.attr_type == attr_types.star:

+ return "&" + ret + "___tmp"

+ return ret + "___tmp"

+ if self.wtype.attr_type != attr_types.star:

+ ret = "*" + ret

+ return self.wtype.name + "::get_py_obj(" + self.gen_varname() + ")"

+

+ #Generate cleanup code

+ def gen_cleanup(self):

+ if self.wtype.name in primitive_types or self.wtype.name in classnames or self.wtype.name in enum_names or not self.wtype.attr_type == attr_types.star or (self.wtype.name in known_containers and self.wtype.attr_type == attr_types.star):

+ return ""

+ return "\n\t\tdelete " + self.gen_varname() + "___tmp;"

+

+class WClass:

+ name = None

+ namespace = None

+ link_type = None

+ id_ = None

+ string_id = None

+ hash_id = None

+ needs_clone = False

+ found_funs = []

+ found_vars = []

+ found_constrs = []

+

+ def __init__(self, name, link_type, id_, string_id = None, hash_id = None, needs_clone = False):

+ self.name = name

+ self.namespace = None

+ self.link_type = link_type

+ self.id_ = id_

+ self.string_id = string_id

+ self.hash_id = hash_id

+ self.needs_clone = needs_clone

+ self.found_funs = []

+ self.found_vars = []

+ self.found_constrs = []

+

+ def printable_constrs(self):

+ ret = 0

+ for con in self.found_constrs:

+ if not con.protected:

+ ret += 1

+ return ret

+

+ def gen_decl(self, filename):

+ long_name = self.namespace + "::" + self.name

+

+ text = "\n\t// WRAPPED from " + filename

+ text += "\n\tstruct " + self.name

+ if self.link_type == link_types.derive:

+ text += " : public " + self.namespace + "::" + self.name

+ text += "\n\t{\n"

+

+ if self.link_type != link_types.derive:

+

+ text += "\t\t" + long_name + "* ref_obj;\n"

+

+ if self.link_type == link_types.ref_copy or self.link_type == link_types.pointer:

+ text += "\n\t\t" + long_name + "* get_cpp_obj() const\n\t\t{\n\t\t\treturn ref_obj;\n\t\t}\n"

+ elif self.link_type == link_types.global_list:

+ text += "\t\t" + self.id_.wtype.name + " " + self.id_.varname + ";\n"

+ text += "\n\t\t" + long_name + "* get_cpp_obj() const\n\t\t{"

+ text += "\n\t\t\t" + long_name + "* ret = " + long_name + "::get_all_" + self.name.lower() + "s()->at(this->" + self.id_.varname + ");"

+ text += "\n\t\t\tif(ret != NULL && ret == this->ref_obj)"

+ text += "\n\t\t\t\treturn ret;"

+ text += "\n\t\t\tthrow std::runtime_error(\"" + self.name + "'s c++ object does not exist anymore.\");"

+ text += "\n\t\t\treturn NULL;"

+ text += "\n\t\t}\n"

+

+ #if self.link_type != link_types.pointer:

+ text += "\n\t\tstatic " + self.name + "* get_py_obj(" + long_name + "* ref)\n\t\t{"

+ text += "\n\t\t\t" + self.name + "* ret = (" + self.name + "*)malloc(sizeof(" + self.name + "));"

+ if self.link_type == link_types.pointer:

+ text += "\n\t\t\tret->ref_obj = ref;"

+ if self.link_type == link_types.ref_copy:

+ if self.needs_clone:

+ text += "\n\t\t\tret->ref_obj = ref->clone();"

+ else:

+ text += "\n\t\t\tret->ref_obj = new "+long_name+"(*ref);"

+ if self.link_type == link_types.global_list:

+ text += "\n\t\t\tret->ref_obj = ref;"

+ text += "\n\t\t\tret->" + self.id_.varname + " = ret->ref_obj->" + self.id_.varname + ";"

+ text += "\n\t\t\treturn ret;"

+ text += "\n\t\t}\n"

+

+ if self.link_type == link_types.ref_copy:

+ text += "\n\t\tstatic " + self.name + "* get_py_obj(" + long_name + " ref)\n\t\t{"

+ text += "\n\t\t\t" + self.name + "* ret = (" + self.name + "*)malloc(sizeof(" + self.name + "));"

+ if self.needs_clone:

+ text += "\n\t\t\tret->ref_obj = ref.clone();"

+ else:

+ text += "\n\t\t\tret->ref_obj = new "+long_name+"(ref);"

+ text += "\n\t\t\treturn ret;"

+ text += "\n\t\t}\n"

+

+ for con in self.found_constrs:

+ text += con.gen_decl()

+ for var in self.found_vars:

+ text += var.gen_decl()

+ for fun in self.found_funs:

+ text += fun.gen_decl()

+

+

+ if self.link_type == link_types.derive:

+ duplicates = {}

+ for fun in self.found_funs:

+ if fun.name in duplicates:

+ fun.gen_alias()

+ duplicates[fun.name].gen_alias()

+ else:

+ duplicates[fun.name] = fun

+

+ text += "\n\t\t" + long_name + "* get_cpp_obj() const\n\t\t{\n\t\t\treturn (" + self.namespace + "::" + self.name +"*)this;\n\t\t}\n"

+ text += "\n\t\tstatic " + self.name + "* get_py_obj(" + long_name + "* ref)\n\t\t{"

+ text += "\n\t\t\treturn (" + self.name + "*)ref;"

+ text += "\n\t\t}\n"

+

+ for con in self.found_constrs:

+ text += con.gen_decl_derive()

+ for var in self.found_vars:

+ text += var.gen_decl()

+ for fun in self.found_funs:

+ text += fun.gen_decl_virtual()

+

+ if self.hash_id != None:

+ text += "\n\t\tunsigned int get_hash_py()"

+ text += "\n\t\t{"

+ text += "\n\t\t\treturn get_cpp_obj()->" + self.hash_id + ";"

+ text += "\n\t\t}"

+

+ text += "\n\t};\n"

+

+ if self.link_type == link_types.derive:

+ text += "\n\tstruct " + self.name + "Wrap : " + self.name + ", boost::python::wrapper<" + self.name + ">"

+ text += "\n\t{"

+

+ for con in self.found_constrs:

+ text += con.gen_decl_wrapperclass()

+ for fun in self.found_funs:

+ text += fun.gen_default_impl()

+

+ text += "\n\t};"

+

+ text += "\n\tstd::ostream &operator<<(std::ostream &ostr, const " + self.name + " &ref)"

+ text += "\n\t{"

+ text += "\n\t\tostr << \"" + self.name

+ if self.string_id != None:

+ text +=" \\\"\""

+ text += " << ref.get_cpp_obj()->" + self.string_id

+ text += " << \"\\\"\""

+ else:

+ text += " at \" << ref.get_cpp_obj()"

+ text += ";"

+ text += "\n\t\treturn ostr;"

+ text += "\n\t}"

+ text += "\n"

+

+ return text

+

+ def gen_funs(self, filename):

+ text = ""

+ if self.link_type != link_types.derive:

+ for con in self.found_constrs:

+ text += con.gen_def()

+ for var in self.found_vars:

+ text += var.gen_def()

+ for fun in self.found_funs:

+ text += fun.gen_def()

+ else:

+ for var in self.found_vars:

+ text += var.gen_def()

+ for fun in self.found_funs:

+ text += fun.gen_def_virtual()

+ return text

+

+ def gen_boost_py(self):

+ text = "\n\t\tclass_<" + self.name

+ if self.link_type == link_types.derive:

+ text += "Wrap, boost::noncopyable"

+ text += ">(\"" + self.name + "\""

+ if self.printable_constrs() == 0 or not self.contains_default_constr():

+ text += ", no_init"

+ text += ")"

+ text += "\n\t\t\t.def(boost::python::self_ns::str(boost::python::self_ns::self))"

+ text += "\n\t\t\t.def(boost::python::self_ns::repr(boost::python::self_ns::self))"

+ for con in self.found_constrs:

+ text += con.gen_boost_py()

+ for var in self.found_vars:

+ text += var.gen_boost_py()

+ static_funs = []

+ for fun in self.found_funs:

+ text += fun.gen_boost_py()

+ if fun.is_static and fun.alias not in static_funs:

+ static_funs.append(fun.alias)

+ for fun in static_funs:

+ text += "\n\t\t\t.staticmethod(\"" + fun + "\")"

+

+ if self.hash_id != None:

+ text += "\n\t\t\t.def(\"__hash__\", &" + self.name + "::get_hash_py)"

+ text += "\n\t\t\t;\n"

+ return text

+

+ def contains_default_constr(self):

+ for c in self.found_constrs:

+ if len(c.args) == 0:

+ return True

+ return False

+

+#CONFIGURE HEADER-FILES TO BE PARSED AND CLASSES EXPECTED IN THEM HERE

+

+sources = [

+ Source("kernel/celltypes",[

+ WClass("CellType", link_types.pointer, None, None, "type.hash()", True),

+ WClass("CellTypes", link_types.pointer, None, None, None, True)

+ ]

+ ),

+ Source("kernel/consteval",[

+ WClass("ConstEval", link_types.pointer, None, None, None, True)

+ ]

+ ),

+ Source("kernel/log",[]),

+ Source("kernel/register",[

+ WClass("Pass", link_types.derive, None, None, None, True),

+ ]

+ ),

+ Source("kernel/rtlil",[

+ WClass("IdString", link_types.ref_copy, None, "str()", "hash()"),

+ WClass("Const", link_types.ref_copy, None, "as_string()", "hash()"),

+ WClass("AttrObject", link_types.ref_copy, None, None, None),

+ WClass("Selection", link_types.ref_copy, None, None, None),

+ WClass("Monitor", link_types.derive, None, None, None),

+ WClass("CaseRule",link_types.ref_copy, None, None, None, True),

+ WClass("SwitchRule",link_types.ref_copy, None, None, None, True),

+ WClass("SyncRule", link_types.ref_copy, None, None, None, True),

+ WClass("Process", link_types.ref_copy, None, "name.c_str()", "name.hash()"),

+ WClass("SigChunk", link_types.ref_copy, None, None, None),

+ WClass("SigBit", link_types.ref_copy, None, None, "hash()"),

+ WClass("SigSpec", link_types.ref_copy, None, None, "hash()"),

+ WClass("Cell", link_types.global_list, Attribute(WType("unsigned int"), "hashidx_"), "name.c_str()", "hash()"),

+ WClass("Wire", link_types.global_list, Attribute(WType("unsigned int"), "hashidx_"), "name.c_str()", "hash()"),

+ WClass("Memory", link_types.global_list, Attribute(WType("unsigned int"), "hashidx_"), "name.c_str()", "hash()"),

+ WClass("Module", link_types.global_list, Attribute(WType("unsigned int"), "hashidx_"), "name.c_str()", "hash()"),

+ WClass("Design", link_types.global_list, Attribute(WType("unsigned int"), "hashidx_"), "hashidx_", "hash()")

+ ]

+ ),

+ #Source("kernel/satgen",[

+ # ]

+ # ),

+ #Source("libs/ezsat/ezsat",[

+ # ]

+ # ),

+ #Source("libs/ezsat/ezminisat",[

+ # ]

+ # ),

+ Source("kernel/sigtools",[

+ WClass("SigMap", link_types.pointer, None, None, None, True)

+ ]

+ ),

+ Source("kernel/yosys",[

+ ]

+ ),

+ Source("kernel/cost",[])

+ ]

+

+blacklist_methods = ["YOSYS_NAMESPACE::Pass::run_register", "YOSYS_NAMESPACE::Module::Pow", "YOSYS_NAMESPACE::Module::Bu0", "YOSYS_NAMESPACE::CaseRule::optimize"]

+

+enum_names = ["State","SyncType","ConstFlags"]

+

+enums = [] #Do not edit

+

+unowned_functions = []

+

+classnames = []

+for source in sources:

+ for wclass in source.classes:

+ classnames.append(wclass.name)

+

+def class_by_name(name):

+ for source in sources:

+ for wclass in source.classes:

+ if wclass.name == name:

+ return wclass

+ return None

+

+def enum_by_name(name):

+ for e in enums:

+ if e.name == name:

+ return e

+ return None

+

+def find_closing(text, open_tok, close_tok):

+ if text.find(open_tok) == -1 or text.find(close_tok) <= text.find(open_tok):

+ return text.find(close_tok)

+ return text.find(close_tok) + find_closing(text[text.find(close_tok)+1:], open_tok, close_tok) + 1

+

+def unpretty_string(s):

+ s = s.strip()

+ while s.find(" ") != -1:

+ s = s.replace(" "," ")

+ while s.find("\t") != -1:

+ s = s.replace("\t"," ")

+ s = s.replace(" (","(")

+ return s

+

+class WEnum:

+ name = None

+ namespace = None

+ values = []

+

+ def from_string(str_def, namespace, line_number):

+ str_def = str_def.strip()

+ if not str.startswith(str_def, "enum "):

+ return None

+ if str_def.count(";") != 1:

+ return None

+ str_def = str_def[5:]

+ enum = WEnum()

+ split = str_def.split(":")

+ if(len(split) != 2):

+ return None

+ enum.name = split[0].strip()

+ if enum.name not in enum_names:

+ return None

+ str_def = split[1]

+ if str_def.count("{") != str_def.count("}") != 1:

+ return None

+ if len(str_def) < str_def.find("}")+2 or str_def[str_def.find("}")+1] != ';':

+ return None

+ str_def = str_def.split("{")[-1].split("}")[0]

+ enum.values = []

+ for val in str_def.split(','):

+ enum.values.append(val.strip().split('=')[0].strip())

+ enum.namespace = namespace

+ return enum

+

+ def gen_boost_py(self):

+ text = "\n\t\tenum_<" + self.namespace + "::" + self.name + ">(\"" + self.name + "\")\n"

+ for value in self.values:

+ text += "\t\t\t.value(\"" + value + "\"," + self.namespace + "::" + value + ")\n"

+ text += "\t\t\t;\n"

+ return text

+

+ def __str__(self):

+ ret = "Enum " + self.namespace + "::" + self.name + "(\n"

+ for val in self.values:

+ ret = ret + "\t" + val + "\n"

+ return ret + ")"

+

+ def __repr__(self):

+ return __str__(self)

+

+class WConstructor:

+ orig_text = None

+ args = []

+ containing_file = None

+ member_of = None

+ duplicate = False

+ protected = False

+

+ def __init__(self, containing_file, class_):

+ self.orig_text = "Auto generated default constructor"

+ self.args = []

+ self.containing_file = containing_file

+ self.member_of = class_

+ self.protected = False

+

+ def from_string(str_def, containing_file, class_, line_number, protected = False):

+ if class_ == None:

+ return None

+ if str_def.count("delete;") > 0:

+ return None

+ con = WConstructor(containing_file, class_)

+ con.orig_text = str_def

+ con.args = []

+ con.duplicate = False

+ con.protected = protected

+ if not str.startswith(str_def, class_.name + "("):

+ return None

+ str_def = str_def[len(class_.name)+1:]

+ found = find_closing(str_def, "(", ")")

+ if found == -1:

+ return None

+ str_def = str_def[0:found].strip()

+ if len(str_def) == 0:

+ return con

+ for arg in split_list(str_def, ","):

+ parsed = Attribute.from_string(arg.strip(), containing_file, line_number)

+ if parsed == None:

+ return None

+ con.args.append(parsed)

+ return con

+

+ def gen_decl(self):

+ if self.duplicate or self.protected:

+ return ""

+ text = "\n\t\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t\t" + self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ");\n"

+ return text

+

+ def gen_decl_derive(self):

+ if self.duplicate or self.protected:

+ return ""

+ text = "\n\t\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t\t" + self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ")"

+ if len(self.args) == 0:

+ return text + "{}"

+ text += " : "

+ text += self.member_of.namespace + "::" + self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_call() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += "){}\n"

+ return text

+

+ def gen_decl_wrapperclass(self):

+ if self.duplicate or self.protected:

+ return ""

+ text = "\n\t\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t\t" + self.member_of.name + "Wrap("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ")"

+ if len(self.args) == 0:

+ return text + "{}"

+ text += " : "

+ text += self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_call() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += "){}\n"

+ return text

+

+ def gen_decl_hash_py(self):

+ text = self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem_hash() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ");"

+ return text

+

+ def gen_def(self):

+ if self.duplicate or self.protected:

+ return ""

+ text = "\n\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t" + self.member_of.name + "::" + self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text +=")\n\t{"

+ for arg in self.args:

+ text += arg.gen_translation()

+ if self.member_of.link_type != link_types.derive:

+ text += "\n\t\tthis->ref_obj = new " + self.member_of.namespace + "::" + self.member_of.name + "("

+ for arg in self.args:

+ text += arg.gen_call() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ if self.member_of.link_type != link_types.derive:

+ text += ");"

+ if self.member_of.link_type == link_types.global_list:

+ text += "\n\t\tthis->" + self.member_of.id_.varname + " = this->ref_obj->" + self.member_of.id_.varname + ";"

+ for arg in self.args:

+ text += arg.gen_cleanup()

+ text += "\n\t}\n"

+ return text

+

+ def gen_boost_py(self):

+ if self.duplicate or self.protected or len(self.args) == 0:

+ return ""

+ text = "\n\t\t\t.def(init"

+ text += "<"

+ for a in self.args:

+ text += a.gen_listitem_hash() + ", "

+ text = text[0:-2] + ">())"

+ return text

+

+class WFunction:

+ orig_text = None

+ is_static = False

+ is_inline = False

+ is_virtual = False

+ ret_attr_type = attr_types.default

+ is_operator = False

+ ret_type = None

+ name = None

+ alias = None

+ args = []

+ containing_file = None

+ member_of = None

+ duplicate = False

+ namespace = ""

+

+ def from_string(str_def, containing_file, class_, line_number, namespace):

+ if str_def.count("delete;") > 0:

+ return None

+ func = WFunction()

+ func.is_static = False

+ func.is_inline = False

+ func.is_virtual = False

+ func.ret_attr_type = attr_types.default

+ func.is_operator = False

+ func.member_of = None

+ func.orig_text = str_def

+ func.args = []

+ func.containing_file = containing_file

+ func.member_of = class_

+ func.duplicate = False

+ func.namespace = namespace

+ str_def = str_def.replace("operator ","operator")

+ if str.startswith(str_def, "static "):

+ func.is_static = True

+ str_def = str_def[7:]

+ else:

+ func.is_static = False

+ if str.startswith(str_def, "inline "):

+ func.is_inline = True

+ str_def = str_def[7:]

+ else:

+ func.is_inline = False

+ if str.startswith(str_def, "virtual "):

+ func.is_virtual = True

+ str_def = str_def[8:]

+ else:

+ func.is_virtual = False

+

+ if str_def.count(" ") == 0:

+ return None

+

+ parts = split_list(str_def.strip(), " ")

+

+ prefix = ""

+ i = 0

+ for part in parts:

+ if part in ["unsigned", "long", "short"]:

+ prefix += part + " "

+ i += 1

+ else:

+ break

+ parts = parts[i:]

+

+ if len(parts) <= 1:

+ return None

+

+ func.ret_type = WType.from_string(prefix + parts[0], containing_file, line_number)

+

+ if func.ret_type == None:

+ return None

+

+ str_def = parts[1]

+ for part in parts[2:]:

+ str_def = str_def + " " + part

+

+ found = str_def.find("(")

+ if found == -1 or (str_def.find(" ") != -1 and found > str_def.find(" ")):

+ return None

+ func.name = str_def[:found]

+ str_def = str_def[found:]

+ if func.name.find("operator") != -1 and str.startswith(str_def, "()("):

+ func.name += "()"

+ str_def = str_def[2:]

+ str_def = str_def[1:]

+ if func.name.find("operator") != -1:

+ func.is_operator = True

+ if func.name.find("*") == 0:

+ func.name = func.name.replace("*", "")

+ func.ret_type.attr_type = attr_types.star

+ if func.name.find("&&") == 0:

+ func.name = func.name.replace("&&", "")

+ func.ret_type.attr_type = attr_types.ampamp

+ if func.name.find("&") == 0:

+ func.name = func.name.replace("&", "")

+ func.ret_type.attr_type = attr_types.amp

+

+ found = find_closing(str_def, "(", ")")

+ if found == -1:

+ return None

+ str_def = str_def[0:found]

+ if func.name in blacklist_methods:

+ return None

+ if func.namespace != None and func.namespace != "":

+ if (func.namespace + "::" + func.name) in blacklist_methods:

+ return None

+ if func.member_of != None:

+ if (func.namespace + "::" + func.member_of.name + "::" + func.name) in blacklist_methods:

+ return None

+ if func.is_operator and func.name.replace(" ","").replace("operator","").split("::")[-1] not in wrappable_operators:

+ return None

+

+ testname = func.name

+ if func.is_operator:

+ testname = testname[:testname.find("operator")]

+ if testname.count(")") != 0 or testname.count("(") != 0 or testname.count("~") != 0 or testname.count(";") != 0 or testname.count(">") != 0 or testname.count("<") != 0 or testname.count("throw") != 0:

+ return None

+

+ func.alias = func.name

+ if func.name in keyword_aliases:

+ func.alias = keyword_aliases[func.name]

+ str_def = str_def[:found].strip()

+ if(len(str_def) == 0):

+ return func

+ for arg in split_list(str_def, ","):

+ if arg.strip() == "...":

+ continue

+ parsed = Attribute.from_string(arg.strip(), containing_file, line_number)

+ if parsed == None:

+ return None

+ func.args.append(parsed)

+ return func

+

+ def gen_alias(self):

+ self.alias = self.name

+ for arg in self.args:

+ self.alias += "__" + arg.wtype.gen_text_cpp().replace("::", "_").replace("<","_").replace(">","_").replace(" ","").replace("*","").replace(",","")

+

+ def gen_decl(self):

+ if self.duplicate:

+ return ""

+ text = "\n\t\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t\t"

+ if self.is_static:

+ text += "static "

+ text += self.ret_type.gen_text() + " " + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem()

+ text += ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ");\n"

+ return text

+

+ def gen_decl_virtual(self):

+ if self.duplicate:

+ return ""

+ if not self.is_virtual:

+ return self.gen_decl()

+ text = "\n\t\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t\tvirtual "

+ if self.is_static:

+ text += "static "

+ text += self.ret_type.gen_text() + " py_" + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem()

+ text += ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ")"

+ if len(self.args) == 0:

+ text += "{}"

+ else:

+ text += "\n\t\t{"

+ for arg in self.args:

+ text += "\n\t\t\t(void)" + arg.gen_varname() + ";"

+ text += "\n\t\t}\n"

+ text += "\n\t\tvirtual "

+ if self.is_static:

+ text += "static "

+ text += self.ret_type.gen_text() + " " + self.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem_cpp()

+ text += ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ") YS_OVERRIDE;\n"

+ return text

+

+ def gen_decl_hash_py(self):

+ text = self.ret_type.gen_text() + " " + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem_hash() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ");"

+ return text

+

+ def gen_def(self):

+ if self.duplicate:

+ return ""

+ text = "\n\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t" + self.ret_type.gen_text() + " "

+ if self.member_of != None:

+ text += self.member_of.name + "::"

+ text += self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem()

+ text += ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text +=")\n\t{"

+ for arg in self.args:

+ text += arg.gen_translation()

+ text += "\n\t\t"

+ if self.ret_type.name != "void":

+ if self.ret_type.name in known_containers:

+ text += self.ret_type.gen_text_cpp()

+ else:

+ text += self.ret_type.gen_text()

+ if self.ret_type.name in classnames or (self.ret_type.name in known_containers and self.ret_type.attr_type == attr_types.star):

+ text += "*"

+ text += " ret_ = "

+ if self.ret_type.name in classnames:

+ text += self.ret_type.name + "::get_py_obj("

+ if self.member_of == None:

+ text += "::" + self.namespace + "::" + self.alias + "("

+ elif self.is_static:

+ text += self.member_of.namespace + "::" + self.member_of.name + "::" + self.name + "("

+ else:

+ text += "this->get_cpp_obj()->" + self.name + "("

+ for arg in self.args:

+ text += arg.gen_call() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ if self.ret_type.name in classnames:

+ text += ")"

+ text += ");"

+ for arg in self.args:

+ text += arg.gen_cleanup()

+ if self.ret_type.name != "void":

+ if self.ret_type.name in classnames:

+ text += "\n\t\treturn *ret_;"

+ elif self.ret_type.name in known_containers:

+ text += known_containers[self.ret_type.name].translate_cpp("ret_", self.ret_type.cont.args, "\n\t\t", self.ret_type.attr_type == attr_types.star)

+ text += "\n\t\treturn ret____tmp;"

+ else:

+ text += "\n\t\treturn ret_;"

+ text += "\n\t}\n"

+ return text

+

+ def gen_def_virtual(self):

+ if self.duplicate:

+ return ""

+ if not self.is_virtual:

+ return self.gen_def()

+ text = "\n\t// WRAPPED from \"" + self.orig_text.replace("\n"," ") + "\" in " + self.containing_file

+ text += "\n\t"

+ if self.is_static:

+ text += "static "

+ text += self.ret_type.gen_text() + " " + self.member_of.name + "::" + self.name + "("

+ for arg in self.args:

+ text += arg.gen_listitem_cpp()

+ text += ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ")\n\t{"

+ for arg in self.args:

+ text += arg.gen_translation_cpp()

+ text += "\n\t\t"

+ if self.member_of == None:

+ text += "::" + self.namespace + "::" + self.alias + "("

+ elif self.is_static:

+ text += self.member_of.namespace + "::" + self.member_of.name + "::" + self.name + "("

+ else:

+ text += "py_" + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_call_cpp() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ if self.ret_type.name in classnames:

+ text += ")"

+ text += ");"

+ for arg in self.args:

+ text += arg.gen_cleanup()

+ text += "\n\t}\n"

+ return text

+

+ def gen_default_impl(self):

+ if self.duplicate:

+ return ""

+ if not self.is_virtual:

+ return ""

+ text = "\n\n\t\t" + self.ret_type.gen_text() + " py_" + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+

+ call_string = "py_" + self.alias + "("

+ for arg in self.args:

+ call_string += arg.gen_varname() + ", "

+ if len(self.args) > 0:

+ call_string = call_string[0:-2]

+ call_string += ");"

+

+ text += ")\n\t\t{"

+ text += "\n\t\t\tif(boost::python::override py_" + self.alias + " = this->get_override(\"py_" + self.alias + "\"))"

+ text += "\n\t\t\t\t" + call_string

+ text += "\n\t\t\telse"

+ text += "\n\t\t\t\t" + self.member_of.name + "::" + call_string

+ text += "\n\t\t}"

+

+ text += "\n\n\t\t" + self.ret_type.gen_text() + " default_py_" + self.alias + "("

+ for arg in self.args:

+ text += arg.gen_listitem() + ", "

+ if len(self.args) > 0:

+ text = text[:-2]

+ text += ")\n\t\t{"

+ text += "\n\t\t\tthis->" + self.member_of.name + "::" + call_string

+ text += "\n\t\t}"

+ return text

+

+

+ def gen_boost_py(self):

+ if self.duplicate:

+ return ""

+ if self.member_of == None:

+ text = "\n\t\tdef"

+ else:

+ text = "\n\t\t\t.def"

+ if len(self.args) > -1:

+ if self.ret_type.name in known_containers:

+ text += "<" + known_containers[self.ret_type.name].typename + " "

+ else:

+ text += "<" + self.ret_type.name + " "

+ if self.member_of == None or self.is_static:

+ text += "(*)("

+ else:

+ text += "(" + self.member_of.name + "::*)("

+ for a in self.args:

+ text += a.gen_listitem_hash() + ", "

+ if len(self.args) > 0:

+ text = text[0:-2] + ")>"

+ else:

+ text += "void)>"

+

+ if self.is_operator:

+ text += "(\"" + wrappable_operators[self.name.replace("operator","")] + "\""

+ else:

+ if self.member_of != None and self.member_of.link_type == link_types.derive and self.is_virtual:

+ text += "(\"py_" + self.alias + "\""

+ else:

+ text += "(\"" + self.alias + "\""

+ if self.member_of != None:

+ text += ", &" + self.member_of.name + "::"

+ if self.member_of.link_type == link_types.derive and self.is_virtual:

+ text += "py_" + self.alias

+ text += ", &" + self.member_of.name + "Wrap::default_py_" + self.alias

+ else:

+ text += self.alias

+

+ text += ")"

+ else:

+ text += ", " + "YOSYS_PYTHON::" + self.alias + ");"

+ return text

+

+class WMember:

+ orig_text = None

+ wtype = attr_types.default

+ name = None

+ containing_file = None

+ member_of = None

+ namespace = ""

+ is_const = False

+

+ def from_string(str_def, containing_file, class_, line_number, namespace):

+ member = WMember()

+ member.orig_text = str_def

+ member.wtype = None

+ member.name = ""

+ member.containing_file = containing_file

+ member.member_of = class_

+ member.namespace = namespace

+ member.is_const = False

+

+ if str.startswith(str_def, "const "):

+ member.is_const = True

+ str_def = str_def[6:]

+

+ if str_def.count(" ") == 0:

+ return None

+

+ parts = split_list(str_def.strip(), " ")

+

+ prefix = ""

+ i = 0

+ for part in parts:

+ if part in ["unsigned", "long", "short"]:

+ prefix += part + " "

+ i += 1

+ else:

+ break

+ parts = parts[i:]

+

+ if len(parts) <= 1:

+ return None

+

+ member.wtype = WType.from_string(prefix + parts[0], containing_file, line_number)

+

+ if member.wtype == None:

+ return None

+

+ str_def = parts[1]

+ for part in parts[2:]:

+ str_def = str_def + " " + part

+

+ if str_def.find("(") != -1 or str_def.find(")") != -1 or str_def.find("{") != -1 or str_def.find("}") != -1:

+ return None

+

+ found = str_def.find(";")

+ if found == -1:

+ return None

+

+ found_eq = str_def.find("=")

+ if found_eq != -1:

+ found = found_eq

+

+ member.name = str_def[:found]

+ str_def = str_def[found+1:]

+ if member.name.find("*") == 0:

+ member.name = member.name.replace("*", "")

+ member.wtype.attr_type = attr_types.star

+ if member.name.find("&&") == 0:

+ member.name = member.name.replace("&&", "")

+ member.wtype.attr_type = attr_types.ampamp

+ if member.name.find("&") == 0:

+ member.name = member.name.replace("&", "")

+ member.wtype.attr_type = attr_types.amp

+

+ if(len(str_def.strip()) != 0):

+ return None

+

+ if len(member.name.split(",")) > 1:

+ member_list = []

+ for name in member.name.split(","):

+ name = name.strip();

+ member_list.append(WMember())

+ member_list[-1].orig_text = member.orig_text

+ member_list[-1].wtype = member.wtype

+ member_list[-1].name = name

+ member_list[-1].containing_file = member.containing_file

+ member_list[-1].member_of = member.member_of

+ member_list[-1].namespace = member.namespace

+ member_list[-1].is_const = member.is_const

+ return member_list

+

+ return member

+

+ def gen_decl(self):

+ text = "\n\t\t" + self.wtype.gen_text() + " get_var_py_" + self.name + "();\n"

+ if self.is_const:

+ return text

+ if self.wtype.name in classnames:

+ text += "\n\t\tvoid set_var_py_" + self.name + "(" + self.wtype.gen_text() + " *rhs);\n"

+ else:

+ text += "\n\t\tvoid set_var_py_" + self.name + "(" + self.wtype.gen_text() + " rhs);\n"

+ return text

+

+ def gen_def(self):

+ text = "\n\t" + self.wtype.gen_text() + " " + self.member_of.name +"::get_var_py_" + self.name + "()"

+ text += "\n\t{\n\t\t"

+ if self.wtype.attr_type == attr_types.star:

+ text += "if(this->get_cpp_obj()->" + self.name + " == NULL)\n\t\t\t"

+ text += "throw std::runtime_error(\"Member \\\"" + self.name + "\\\" is NULL\");\n\t\t"

+ if self.wtype.name in known_containers:

+ text += self.wtype.gen_text_cpp()

+ else:

+ text += self.wtype.gen_text()

+

+ if self.wtype.name in classnames or (self.wtype.name in known_containers and self.wtype.attr_type == attr_types.star):

+ text += "*"

+ text += " ret_ = "

+ if self.wtype.name in classnames:

+ text += self.wtype.name + "::get_py_obj("

+ if self.wtype.attr_type != attr_types.star:

+ text += "&"

+ text += "this->get_cpp_obj()->" + self.name

+ if self.wtype.name in classnames:

+ text += ")"

+ text += ";"

+

+ if self.wtype.name in classnames:

+ text += "\n\t\treturn *ret_;"

+ elif self.wtype.name in known_containers:

+ text += known_containers[self.wtype.name].translate_cpp("ret_", self.wtype.cont.args, "\n\t\t", self.wtype.attr_type == attr_types.star)

+ text += "\n\t\treturn ret____tmp;"

+ else:

+ text += "\n\t\treturn ret_;"

+ text += "\n\t}\n"

+

+ if self.is_const:

+ return text

+

+ ret = Attribute(self.wtype, "rhs");

+

+ if self.wtype.name in classnames:

+ text += "\n\tvoid " + self.member_of.name+ "::set_var_py_" + self.name + "(" + self.wtype.gen_text() + " *rhs)"

+ else:

+ text += "\n\tvoid " + self.member_of.name+ "::set_var_py_" + self.name + "(" + self.wtype.gen_text() + " rhs)"

+ text += "\n\t{"

+ text += ret.gen_translation()

+ text += "\n\t\tthis->get_cpp_obj()->" + self.name + " = " + ret.gen_call() + ";"

+ text += "\n\t}\n"

+

+ return text;

+

+ def gen_boost_py(self):

+ text = "\n\t\t\t.add_property(\"" + self.name + "\", &" + self.member_of.name + "::get_var_py_" + self.name

+ if not self.is_const:

+ text += ", &" + self.member_of.name + "::set_var_py_" + self.name

+ text += ")"

+ return text

+

+def concat_namespace(tuple_list):

+ if len(tuple_list) == 0:

+ return ""

+ ret = ""

+ for namespace in tuple_list:

+ ret += "::" + namespace[0]

+ return ret[2:]

+

+def calc_ident(text):

+ if len(text) == 0 or text[0] != ' ':

+ return 0

+ return calc_ident(text[1:]) + 1

+

+def assure_length(text, length, left = False):

+ if len(text) > length:

+ return text[:length]

+ if left:

+ return text + " "*(length - len(text))

+ return " "*(length - len(text)) + text

+

+def parse_header(source):

+ debug("Parsing " + source.name + ".pyh",1)

+ source_file = open(source.name + ".pyh", "r")

+

+ source_text = []

+ in_line = source_file.readline()

+

+ namespaces = []

+

+ while(in_line):

+ if(len(in_line)>1):

+ source_text.append(in_line.replace("char *", "char_p ").replace("char* ", "char_p "))

+ in_line = source_file.readline()

+

+ i = 0

+

+ namespaces = []

+ class_ = None

+ private_segment = False

+

+ while i < len(source_text):

+ line = source_text[i].replace("YOSYS_NAMESPACE_BEGIN", " namespace YOSYS_NAMESPACE{").replace("YOSYS_NAMESPACE_END"," }")

+ ugly_line = unpretty_string(line)

+

+ if str.startswith(ugly_line, "namespace "):# and ugly_line.find("std") == -1 and ugly_line.find("__") == -1:

+ namespace_name = ugly_line[10:].replace("{","").strip()

+ namespaces.append((namespace_name, ugly_line.count("{")))

+ debug("-----NAMESPACE " + concat_namespace(namespaces) + "-----",3)

+ i += 1

+ continue

+

+ if len(namespaces) != 0:

+ namespaces[-1] = (namespaces[-1][0], namespaces[-1][1] + ugly_line.count("{") - ugly_line.count("}"))

+ if namespaces[-1][1] == 0:

+ debug("-----END NAMESPACE " + concat_namespace(namespaces) + "-----",3)

+ del namespaces[-1]

+ i += 1

+ continue

+

+ if class_ == None and (str.startswith(ugly_line, "struct ") or str.startswith(ugly_line, "class")) and ugly_line.count(";") == 0:

+

+ struct_name = ugly_line.split(" ")[1].split("::")[-1]

+ impl_namespaces = ugly_line.split(" ")[1].split("::")[:-1]

+ complete_namespace = concat_namespace(namespaces)

+ for namespace in impl_namespaces:

+ complete_namespace += "::" + namespace

+ debug("\tFound " + struct_name + " in " + complete_namespace,2)

+ class_ = (class_by_name(struct_name), ugly_line.count("{"))#calc_ident(line))

+ if struct_name in classnames:

+ class_[0].namespace = complete_namespace

+ i += 1

+ continue

+

+ if class_ != None:

+ class_ = (class_[0], class_[1] + ugly_line.count("{") - ugly_line.count("}"))

+ if class_[1] == 0:

+ if class_[0] == None:

+ debug("\tExiting unknown class", 3)

+ else:

+ debug("\tExiting class " + class_[0].name, 3)

+ class_ = None

+ private_segment = False

+ i += 1

+ continue

+

+ if class_ != None and (line.find("private:") != -1 or line.find("protected:") != -1):

+ private_segment = True

+ i += 1

+ continue

+ if class_ != None and line.find("public:") != -1:

+ private_segment = False

+ i += 1

+ continue

+

+ candidate = None

+

+ if private_segment and class_ != None and class_[0] != None:

+ candidate = WConstructor.from_string(ugly_line, source.name, class_[0], i, True)

+ if candidate != None:

+ debug("\t\tFound constructor of class \"" + class_[0].name + "\" in namespace " + concat_namespace(namespaces),2)

+ class_[0].found_constrs.append(candidate)

+ i += 1

+ continue

+

+ if not private_segment and (class_ == None or class_[0] != None):

+ if class_ != None:

+ candidate = WFunction.from_string(ugly_line, source.name, class_[0], i, concat_namespace(namespaces))

+ else:

+ candidate = WFunction.from_string(ugly_line, source.name, None, i, concat_namespace(namespaces))

+ if candidate != None and candidate.name.find("::") == -1:

+ if class_ == None:

+ debug("\tFound unowned function \"" + candidate.name + "\" in namespace " + concat_namespace(namespaces),2)

+ unowned_functions.append(candidate)

+ else:

+ debug("\t\tFound function \"" + candidate.name + "\" of class \"" + class_[0].name + "\" in namespace " + concat_namespace(namespaces),2)

+ class_[0].found_funs.append(candidate)

+ else:

+ candidate = WEnum.from_string(ugly_line, concat_namespace(namespaces), i)

+ if candidate != None:

+ enums.append(candidate)

+ debug("\tFound enum \"" + candidate.name + "\" in namespace " + concat_namespace(namespaces),2)

+ elif class_ != None and class_[1] == 1:

+ candidate = WConstructor.from_string(ugly_line, source.name, class_[0], i)

+ if candidate != None:

+ debug("\t\tFound constructor of class \"" + class_[0].name + "\" in namespace " + concat_namespace(namespaces),2)

+ class_[0].found_constrs.append(candidate)

+ else:

+ candidate = WMember.from_string(ugly_line, source.name, class_[0], i, concat_namespace(namespaces))

+ if candidate != None:

+ if type(candidate) == list:

+ for c in candidate:

+ debug("\t\tFound member \"" + c.name + "\" of class \"" + class_[0].name + "\" of type \"" + c.wtype.name + "\"", 2)

+ class_[0].found_vars.extend(candidate)

+ else:

+ debug("\t\tFound member \"" + candidate.name + "\" of class \"" + class_[0].name + "\" of type \"" + candidate.wtype.name + "\"", 2)

+ class_[0].found_vars.append(candidate)

+

+ j = i

+ line = unpretty_string(line)

+ while candidate == None and j+1 < len(source_text) and line.count(';') <= 1 and line.count("(") >= line.count(")"):

+ j += 1

+ line = line + "\n" + unpretty_string(source_text[j])

+ if class_ != None:

+ candidate = WFunction.from_string(ugly_line, source.name, class_[0], i, concat_namespace(namespaces))

+ else:

+ candidate = WFunction.from_string(ugly_line, source.name, None, i, concat_namespace(namespaces))

+ if candidate != None and candidate.name.find("::") == -1:

+ if class_ == None:

+ debug("\tFound unowned function \"" + candidate.name + "\" in namespace " + concat_namespace(namespaces),2)

+ unowned_functions.append(candidate)

+ else:

+ debug("\t\tFound function \"" + candidate.name + "\" of class \"" + class_[0].name + "\" in namespace " + concat_namespace(namespaces),2)

+ class_[0].found_funs.append(candidate)

+ continue

+ candidate = WEnum.from_string(line, concat_namespace(namespaces), i)

+ if candidate != None:

+ enums.append(candidate)

+ debug("\tFound enum \"" + candidate.name + "\" in namespace " + concat_namespace(namespaces),2)

+ continue

+ if class_ != None:

+ candidate = WConstructor.from_string(line, source.name, class_[0], i)

+ if candidate != None:

+ debug("\t\tFound constructor of class \"" + class_[0].name + "\" in namespace " + concat_namespace(namespaces),2)

+ class_[0].found_constrs.append(candidate)

+ continue

+ if candidate != None:

+ while i < j:

+ i += 1

+ line = source_text[i].replace("YOSYS_NAMESPACE_BEGIN", " namespace YOSYS_NAMESPACE{").replace("YOSYS_NAMESPACE_END"," }")

+ ugly_line = unpretty_string(line)

+ if len(namespaces) != 0:

+ namespaces[-1] = (namespaces[-1][0], namespaces[-1][1] + ugly_line.count("{") - ugly_line.count("}"))

+ if namespaces[-1][1] == 0:

+ debug("-----END NAMESPACE " + concat_namespace(namespaces) + "-----",3)

+ del namespaces[-1]

+ if class_ != None:

+ class_ = (class_[0] , class_[1] + ugly_line.count("{") - ugly_line.count("}"))

+ if class_[1] == 0:

+ if class_[0] == None:

+ debug("\tExiting unknown class", 3)

+ else:

+ debug("\tExiting class " + class_[0].name, 3)

+ class_ = None

+ private_segment = False

+ i += 1

+ else:

+ i += 1

+

+def debug(message, level):

+ if level <= debug.debug_level:

+ print(message)

+

+def expand_function(f):

+ fun_list = []

+ arg_list = []

+ for arg in f.args:

+ if arg.default_value != None and (arg.wtype.name.split(" ")[-1] in primitive_types or arg.wtype.name in enum_names or (arg.wtype.name in classnames and arg.default_value == "nullptr")):

+ fi = copy.deepcopy(f)

+ fi.args = copy.deepcopy(arg_list)

+ fun_list.append(fi)

+ arg_list.append(arg)

+ fun_list.append(f)

+ return fun_list

+

+def expand_functions():

+ global unowned_functions

+ new_funs = []

+ for fun in unowned_functions:

+ new_funs.extend(expand_function(fun))

+ unowned_functions = new_funs

+ for source in sources:

+ for class_ in source.classes:

+ new_funs = []

+ for fun in class_.found_funs:

+ new_funs.extend(expand_function(fun))

+ class_.found_funs = new_funs

+

+def clean_duplicates():

+ for source in sources:

+ for class_ in source.classes:

+ known_decls = {}

+ for fun in class_.found_funs:

+ if fun.gen_decl_hash_py() in known_decls:

+ debug("Multiple declarations of " + fun.gen_decl_hash_py(),3)

+ other = known_decls[fun.gen_decl_hash_py()]

+ other.gen_alias()

+ fun.gen_alias()

+ if fun.gen_decl_hash_py() == other.gen_decl_hash_py():

+ fun.duplicate = True

+ debug("Disabled \"" + fun.gen_decl_hash_py() + "\"", 3)

+ else:

+ known_decls[fun.gen_decl_hash_py()] = fun

+ known_decls = []

+ for con in class_.found_constrs:

+ if con.gen_decl_hash_py() in known_decls:

+ debug("Multiple declarations of " + con.gen_decl_hash_py(),3)

+ con.duplicate = True

+ else:

+ known_decls.append(con.gen_decl_hash_py())

+ known_decls = []

+ for fun in unowned_functions:

+ if fun.gen_decl_hash_py() in known_decls:

+ debug("Multiple declarations of " + fun.gen_decl_hash_py(),3)

+ fun.duplicate = True

+ else:

+ known_decls.append(fun.gen_decl_hash_py())

+

+def gen_wrappers(filename, debug_level_ = 0):

+ debug.debug_level = debug_level_

+ for source in sources:

+ parse_header(source)

+

+ expand_functions()

+ clean_duplicates()

+

+ import shutil

+ import math

+ col = shutil.get_terminal_size((80,20)).columns

+ debug("-"*col, 1)

+ debug("-"*math.floor((col-7)/2)+"SUMMARY"+"-"*math.ceil((col-7)/2), 1)

+ debug("-"*col, 1)

+ for source in sources:

+ for class_ in source.classes:

+ debug("Class " + assure_length(class_.name, len(max(classnames, key=len)), True) + " contains " + assure_length(str(len(class_.found_vars)), 3, False) + " member variables, "+ assure_length(str(len(class_.found_funs)), 3, False) + " methods and " + assure_length(str(len(class_.found_constrs)), 2, False) + " constructors", 1)

+ if len(class_.found_constrs) == 0:

+ class_.found_constrs.append(WConstructor(source.name, class_))

+ debug(str(len(unowned_functions)) + " functions are unowned", 1)

+ for enum in enums:

+ debug("Enum " + assure_length(enum.name, len(max(enum_names, key=len)), True) + " contains " + assure_length(str(len(enum.values)), 2, False) + " values", 1)

+ debug("-"*col, 1)

+ wrapper_file = open(filename, "w+")

+ wrapper_file.write(

+"""/*

+ * yosys -- Yosys Open SYnthesis Suite

+ *

+ * Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>

+ *

+ * 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.

+ *

+ * This is a generated file and can be overwritten by make

+ */

+

+#ifdef WITH_PYTHON

+""")

+ for source in sources:

+ wrapper_file.write("#include \""+source.name+".h\"\n")

+ wrapper_file.write("""

+#include <boost/python/module.hpp>

+#include <boost/python/class.hpp>

+#include <boost/python/wrapper.hpp>

+#include <boost/python/call.hpp>

+#include <boost/python.hpp>

+#include <boost/log/exceptions.hpp>

+

+USING_YOSYS_NAMESPACE

+

+namespace YOSYS_PYTHON {

+""")

+

+ for source in sources:

+ for wclass in source.classes:

+ wrapper_file.write("\n\tstruct " + wclass.name + ";")

+

+ wrapper_file.write("\n")

+

+ for source in sources:

+ for wclass in source.classes:

+ wrapper_file.write(wclass.gen_decl(source.name))

+

+ wrapper_file.write("\n")

+

+ for source in sources:

+ for wclass in source.classes:

+ wrapper_file.write(wclass.gen_funs(source.name))

+

+ for fun in unowned_functions:

+ wrapper_file.write(fun.gen_def())

+

+ wrapper_file.write(""" struct Initializer

+ {

+ Initializer() {

+ if(!Yosys::yosys_already_setup())

+ {

+ Yosys::log_streams.push_back(&std::cout);

+ Yosys::log_error_stderr = true;

+ Yosys::yosys_setup();

+ Yosys::yosys_banner();

+ }

+ }

+

+ Initializer(Initializer const &) {}

+

+ ~Initializer() {

+ Yosys::yosys_shutdown();

+ }

+ };

+

+ BOOST_PYTHON_MODULE(libyosys)

+ {

+ using namespace boost::python;

+

+ class_<Initializer>("Initializer");

+ scope().attr("_hidden") = new Initializer();

+""")

+

+ for enum in enums:

+ wrapper_file.write(enum.gen_boost_py())

+

+ for source in sources:

+ for wclass in source.classes:

+ wrapper_file.write(wclass.gen_boost_py())

+

+ for fun in unowned_functions:

+ wrapper_file.write(fun.gen_boost_py())

+

+ wrapper_file.write("\n\t}\n}\n#endif")

+

+def print_includes():

+ for source in sources:

+ print(source.name + ".pyh")

+ if (mod->get_blackbox_attribute())

+ if (it.second->get_blackbox_attribute())

+ if (mod->get_blackbox_attribute())

+ if (mod->get_blackbox_attribute())

+ if (mod->get_blackbox_attribute())

+#ifdef WITH_PYTHON

+# include <boost/algorithm/string/predicate.hpp>

+# include <Python.h>

+# include <boost/filesystem.hpp>

+#endif

+

+#ifdef WITH_PYTHON

+std::map<std::string, void*> loaded_python_plugins;

+#endif

+ #ifdef WITH_PYTHON

+ if (!loaded_plugins.count(filename) && !loaded_python_plugins.count(filename)) {

+ #else

+ #endif

+

+ #ifdef WITH_PYTHON

+

+ boost::filesystem::path full_path(filename);

+

+ if(strcmp(full_path.extension().c_str(), ".py") == 0)

+ {

+ std::string path(full_path.parent_path().c_str());

+ filename = full_path.filename().c_str();

+ filename = filename.substr(0,filename.size()-3);

+ PyRun_SimpleString(("sys.path.insert(0,\""+path+"\")").c_str());

+ PyErr_Print();

+ PyObject *module_p = PyImport_ImportModule(filename.c_str());

+ if(module_p == NULL)

+ {

+ PyErr_Print();

+ log_cmd_error("Can't load python module `%s'\n", full_path.filename().c_str());

+ return;

+ }

+ loaded_python_plugins[orig_filename] = module_p;

+ Pass::init_register();

+ } else {

+ #endif

+

+

+ #ifdef WITH_PYTHON

+ }

+ #endif

+#ifdef WITH_PYTHON

+ if (loaded_plugins.empty() and loaded_python_plugins.empty())

+#else

+#endif

+#ifdef WITH_PYTHON

+ for (auto &it : loaded_python_plugins)

+ log(" %s\n", it.first.c_str());

+#endif

+

+struct WbflipPass : public Pass {

+ WbflipPass() : Pass("wbflip", "flip the whitebox attribute") { }

+ void help() YS_OVERRIDE

+ {

+ // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|

+ log("\n");

+ log(" wbflip [selection]\n");

+ log("\n");

+ log("Flip the whitebox attribute on selected cells. I.e. if it's set, unset it, and\n");

+ log("vice-versa. Blackbox cells are not effected by this command.\n");

+ log("\n");

+ }

+ void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE

+ {

+ size_t argidx;

+ for (argidx = 1; argidx < args.size(); argidx++)

+ {

+ std::string arg = args[argidx];

+ // if (arg == "-mod") {

+ // flag_mod = true;

+ // continue;

+ // }

+ break;

+ }

+ extra_args(args, argidx, design);

+

+ for (Module *module : design->modules())

+ {

+ if (!design->selected(module))

+ continue;

+

+ if (module->get_bool_attribute("\\blackbox"))

+ continue;

+

+ module->set_bool_attribute("\\whitebox", !module->get_bool_attribute("\\whitebox"));

+ }

+ }

+} WbflipPass;

+

+ if (!driver && c.wire == nullptr) {

+ RTLIL::State s1 = c.data.front();

+ for (auto s2 : c.data)

+ if (s1 != s2)

+ goto not_const_stream;

+ net.clear();

+ } else {

+ not_const_stream:

+ net = gen_signode_simple(c, false);

+ log_assert(!net.empty());

+ }

+ log_assert(!net.empty());

+ } else

+ if (net.empty()) {

+ log_assert(rep == 1);

+ label_string += stringf("%c -&gt; %d:%d |",

+ c.data.front() == State::S0 ? '0' :

+ c.data.front() == State::S1 ? '1' :

+ c.data.front() == State::Sx ? 'X' :

+ c.data.front() == State::Sz ? 'Z' : '?',

+ pos, pos-rep*c.width+1);

+ if (module->get_blackbox_attribute()) {

+ if (mod_it.second->get_blackbox_attribute())

+struct DebugPass : public Pass {

+ DebugPass() : Pass("debug", "run command with debug log messages enabled") { }

+ void help() YS_OVERRIDE

+ {

+ // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|

+ log("\n");

+ log(" debug cmd\n");

+ log("\n");

+ log("Execute the specified command with debug log messages enabled\n");

+ log("\n");

+ }

+ void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE

+ {

+ size_t argidx;

+ for (argidx = 1; argidx < args.size(); argidx++)

+ {

+ // .. parse options ..

+ break;

+ }

+

+ log_force_debug++;

+

+ try {

+ std::vector<std::string> new_args(args.begin() + argidx, args.end());

+ Pass::call(design, new_args);

+ } catch (...) {

+ log_force_debug--;

+ throw;

+ }

+

+ log_force_debug--;

+ }

+} DebugPass;

+

+ log(" produce an error if the circuits are not equivalent.\n");

+ log("\n");

+ log(" -undef\n");

+ log(" enable modelling of undef states during equiv_induct.\n");

+ bool assert, undef;

+ undef = false;

+ if (args[argidx] == "-undef") {

+ undef = true;

+ continue;

+ }

+ run("techmap -wb -D EQUIV -autoproc" + opts);

+ if (help_mode)

+ run("equiv_induct [-undef] equiv");

+ else if (undef)

+ run("equiv_induct -undef equiv");

+ else

+ run("equiv_induct equiv");

+ if (design->modules_.at(cell->type)->get_blackbox_attribute()) {

+ log_error("Module `%s' referenced in module `%s' in cell `%s' is a blackbox/whitebox module.\n",

+ else if (!mod->get_blackbox_attribute())

+ if (!purge_lib && mod->get_blackbox_attribute())

+ if (m->get_blackbox_attribute() && !cell->parameters.empty() && m->get_bool_attribute("\\dynports")) {

+ if (tmod->get_blackbox_attribute())

+OBJS += passes/opt/pmux2shiftx.o

+ log_debug(" removing unused `%s' cell `%s'.\n", cell->type.c_str(), cell->name.c_str());

+ Const initval;

+ if (wire->attributes.count("\\init"))

+ initval = wire->attributes.at("\\init");

+ if (GetSize(initval) != GetSize(wire))

+ initval.bits.resize(GetSize(wire), State::Sx);

+ if (s2[i] == State::Sx && (initval[i] == State::S0 || initval[i] == State::S1)) {

+ s2[i] = initval[i];

+ initval[i] = State::Sx;

+ }

+ if (initval.is_fully_undef())

+ wire->attributes.erase("\\init");

+ else

+ wire->attributes.at("\\init") = initval;

+ log_debug(" removing unused non-port wire %s.\n", wire->name.c_str());

+ log_debug(" removed %d unused temporary wires.\n", del_wires_count);

+ log_debug(" removing redundant init attribute on %s.\n", log_id(wire));

+ log_debug(" removing buffer cell `%s': %s = %s\n", cell->name.c_str(),

+ log_suppressed();

+ dict<SigBit, pair<Wire*, State>> initbits;

+ pool<Wire*> revisit_initwires;

+

+ if (wire->attributes.count("\\init")) {

+ SigSpec sig = sigmap(wire);

+ Const initval = wire->attributes.at("\\init");

+ for (int i = 0; i < GetSize(initval) && i < GetSize(wire); i++) {

+ if (initval[i] == State::S0 || initval[i] == State::S1)

+ initbits[sig[i]] = make_pair(wire, initval[i]);

+ }

+ }

+ Const val(RTLIL::State::Sx, GetSize(sig));

+ for (int i = 0; i < GetSize(sig); i++) {

+ SigBit bit = sigmap(sig[i]);

+ auto cursor = initbits.find(bit);

+ if (cursor != initbits.end()) {

+ revisit_initwires.insert(cursor->second.first);

+ val[i] = cursor->second.second;

+ }

+ }

+

+ log_debug("Setting undriven signal in %s to constant: %s = %s\n", RTLIL::id2cstr(module->name), log_signal(sig), log_signal(val));

+ module->connect(sig, val);

+

+ if (!revisit_initwires.empty())

+ {

+ SigMap sm2(module);

+

+ for (auto wire : revisit_initwires) {

+ SigSpec sig = sm2(wire);

+ Const initval = wire->attributes.at("\\init");

+ for (int i = 0; i < GetSize(initval) && i < GetSize(wire); i++) {

+ if (SigBit(initval[i]) == sig[i])

+ initval[i] = State::Sx;

+ }

+ if (initval.is_fully_undef())

+ wire->attributes.erase("\\init");

+ else

+ wire->attributes["\\init"] = initval;

+ }

+ }

+ log_debug("Replacing %s cell `%s' (%s) in module `%s' with constant driver `%s = %s'.\n",

+ log_debug("Replacing %s cell `%s' in module `%s' with cells using grouped bits:\n",

+ log_debug(" Direct Connection: %s (%s with %s)\n", log_signal(new_b), log_id(cell->type), log_signal(new_a));

+ log_debug(" New cell `%s': A=%s", log_id(c), log_signal(new_a));

+ log_debug(", B=%s", log_signal(new_b));

+ log_debug("\n");

+ log_debug("Inverting %s of %s cell `%s' in module `%s': %s -> %s\n",

+ log_debug("Inverting %s of %s cell `%s' in module `%s': %s -> %s\n",

+ log_debug("Replacing %s cell `%s' in module `%s' with $not cell.\n",

+ did_something = true;

+ log_debug("Replacing port A of %s cell `%s' in module `%s' with shorter expression: %s -> %s\n",

+ log_debug("Replacing port B of %s cell `%s' in module `%s' with shorter expression: %s -> %s\n",

+ log_debug("Replacing port A of %s cell `%s' in module `%s' with constant driver: %s -> %s\n",

+ log_debug("Replacing port A of %s cell `%s' in module `%s' with constant driver: %s -> %s\n",

+ log_debug("Replacing port B of %s cell `%s' in module `%s' with constant driver: %s -> %s\n",

+ log_debug("Optimizing away select inverter for %s cell `%s' in module `%s'.\n", log_id(cell->type), log_id(cell), log_id(module));

+ log_debug("Replacing data input of %s cell `%s' in module `%s' with constant undef.\n",

+ log_debug("Replacing %s cell `%s' in module `%s' with inverter.\n", log_id(cell->type), log_id(cell), log_id(module));

+ log_debug("Replacing %s cell `%s' in module `%s' with %s.\n", log_id(cell->type), log_id(cell),

+ log_debug("Replacing %s cell `%s' (B=%s, SHR=%d) in module `%s' with fixed wiring: %s\n",

+ log_debug("Replacing %s cell `%s' in module `%s' with identity for port %c.\n",

+ log_debug("Replacing %s cell `%s' in module `%s' with inverter.\n", log_id(cell->type), log_id(cell), log_id(module));

+ log_debug("Replacing %s cell `%s' in module `%s' with and-gate.\n", log_id(cell->type), log_id(cell), log_id(module));

+ log_debug("Replacing %s cell `%s' in module `%s' with or-gate.\n", log_id(cell->type), log_id(cell), log_id(module));

+ log_debug("Optimized away %d select inputs of %s cell `%s' in module `%s'.\n",

+ log_debug("Replacing multiply-by-zero cell `%s' in module `%s' with zero-driver.\n",

+ log_debug("Replacing multiply-by-%d cell `%s' in module `%s' with shift-by-%d.\n",

+ log_debug("Replacing divide-by-zero cell `%s' in module `%s' with undef-driver.\n",

+ log_debug("Replacing divide-by-%d cell `%s' in module `%s' with shift-by-%d.\n",

+ log_debug("Replacing modulo-by-%d cell `%s' in module `%s' with bitmask.\n",

+ log_debug("Replacing cell `%s' in module `%s' with constant driver %s.\n",

+ log_debug("Removed %d redundant input bits from %s cell `%s' in module `%s'.\n",

+ log_debug("Replacing %s cell `%s' (implementing %s) with %s.\n",

+ log("Optimizing module %s.\n", log_id(module));

+

+ if (undriven) {

+ did_something = false;

+ if (did_something)

+ design->scratchpad_set_bool("opt.did_something", true);

+ }

+ if (did_something)

+ design->scratchpad_set_bool("opt.did_something", true);

+

+ log_suppressed();

+ log_debug(" Cell `%s' is identical to cell `%s'.\n", cell->name.c_str(), sharemap[cell]->name.c_str());

+ log_debug(" Redirecting output %s: %s = %s\n", it.first.c_str(),

+ log_debug(" Removing %s cell `%s' from module `%s'.\n", cell->type.c_str(), cell->name.c_str(), module->name.c_str());

+

+ log_suppressed();

+ log_debug(" Root of a mux tree: %s%s\n", log_id(mux2info[mux_idx].cell), root_enable_muxes.at(mux_idx) ? " (pure)" : "");

+ log_debug(" Root of a mux tree: %s (rerun as non-pure)\n", log_id(mux2info[mux_idx].cell));

+ log_debug(" Removing pure flag from root mux %s.\n", log_id(mux2info[m].cell));

+/*

+ * yosys -- Yosys Open SYnthesis Suite

+ *

+ * Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>

+ *

+ * 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.

+ *

+ */

+

+#include "kernel/yosys.h"

+#include "kernel/sigtools.h"

+

+USING_YOSYS_NAMESPACE

+PRIVATE_NAMESPACE_BEGIN

+

+struct OnehotDatabase

+{

+ Module *module;

+ const SigMap &sigmap;

+ bool verbose = false;

+ bool initialized = false;

+

+ pool<SigBit> init_ones;

+ dict<SigSpec, pool<SigSpec>> sig_sources_db;

+ dict<SigSpec, bool> sig_onehot_cache;

+ pool<SigSpec> recursion_guard;

+

+ OnehotDatabase(Module *module, const SigMap &sigmap) : module(module), sigmap(sigmap)

+ {

+ }

+

+ void initialize()

+ {

+ log_assert(!initialized);

+ initialized = true;

+

+ for (auto wire : module->wires())

+ {

+ auto it = wire->attributes.find("\\init");

+ if (it == wire->attributes.end())

+ continue;

+

+ auto &val = it->second;

+ int width = std::max(GetSize(wire), GetSize(val));

+

+ for (int i = 0; i < width; i++)

+ if (val[i] == State::S1)

+ init_ones.insert(sigmap(SigBit(wire, i)));

+ }

+

+ for (auto cell : module->cells())

+ {

+ vector<SigSpec> inputs;

+ SigSpec output;

+

+ if (cell->type.in("$adff", "$dff", "$dffe", "$dlatch", "$ff"))

+ {

+ output = cell->getPort("\\Q");

+ if (cell->type == "$adff")

+ inputs.push_back(cell->getParam("\\ARST_VALUE"));

+ inputs.push_back(cell->getPort("\\D"));

+ }

+

+ if (cell->type.in("$mux", "$pmux"))

+ {

+ output = cell->getPort("\\Y");

+ inputs.push_back(cell->getPort("\\A"));

+ SigSpec B = cell->getPort("\\B");

+ for (int i = 0; i < GetSize(B); i += GetSize(output))

+ inputs.push_back(B.extract(i, GetSize(output)));

+ }

+

+ if (!output.empty())

+ {

+ output = sigmap(output);

+ auto &srcs = sig_sources_db[output];

+ for (auto src : inputs) {

+ while (!src.empty() && src[GetSize(src)-1] == State::S0)

+ src.remove(GetSize(src)-1);

+ srcs.insert(sigmap(src));

+ }

+ }

+ }

+ }

+

+ void query_worker(const SigSpec &sig, bool &retval, bool &cache, int indent)

+ {

+ if (verbose)

+ log("%*s %s\n", indent, "", log_signal(sig));

+ log_assert(retval);

+

+ if (recursion_guard.count(sig)) {

+ if (verbose)

+ log("%*s - recursion\n", indent, "");

+ cache = false;

+ return;

+ }

+

+ auto it = sig_onehot_cache.find(sig);

+ if (it != sig_onehot_cache.end()) {

+ if (verbose)

+ log("%*s - cached (%s)\n", indent, "", it->second ? "true" : "false");

+ if (!it->second)

+ retval = false;

+ return;

+ }

+

+ bool found_init_ones = false;

+ for (auto bit : sig) {

+ if (init_ones.count(bit)) {

+ if (found_init_ones) {

+ if (verbose)

+ log("%*s - non-onehot init value\n", indent, "");

+ retval = false;

+ break;

+ }

+ found_init_ones = true;

+ }

+ }

+

+ if (retval)

+ {

+ if (sig.is_fully_const())

+ {

+ bool found_ones = false;

+ for (auto bit : sig) {

+ if (bit == State::S1) {

+ if (found_ones) {

+ if (verbose)

+ log("%*s - non-onehot constant\n", indent, "");

+ retval = false;

+ break;

+ }

+ found_ones = true;

+ }

+ }

+ }

+ else

+ {

+ auto srcs = sig_sources_db.find(sig);

+ if (srcs == sig_sources_db.end()) {

+ if (verbose)

+ log("%*s - no sources for non-const signal\n", indent, "");

+ retval = false;

+ } else {

+ for (auto &src : srcs->second) {

+ bool child_cache = true;

+ recursion_guard.insert(sig);

+ query_worker(src, retval, child_cache, indent+4);

+ recursion_guard.erase(sig);

+ if (!child_cache)

+ cache = false;

+ if (!retval)

+ break;

+ }

+ }

+ }

+ }

+

+ // it is always safe to cache a negative result

+ if (cache || !retval)

+ sig_onehot_cache[sig] = retval;

+ }

+

+ bool query(const SigSpec &sig)

+ {

+ bool retval = true;

+ bool cache = true;

+

+ if (verbose)

+ log("** ONEHOT QUERY START (%s)\n", log_signal(sig));

+

+ if (!initialized)

+ initialize();

+

+ query_worker(sig, retval, cache, 3);

+

+ if (verbose)

+ log("** ONEHOT QUERY RESULT = %s\n", retval ? "true" : "false");

+

+ // it is always safe to cache the root result of a query

+ if (!cache)

+ sig_onehot_cache[sig] = retval;

+

+ return retval;

+ }

+};

+

+struct Pmux2ShiftxPass : public Pass {

+ Pmux2ShiftxPass() : Pass("pmux2shiftx", "transform $pmux cells to $shiftx cells") { }

+ void help() YS_OVERRIDE

+ {

+ // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|

+ log("\n");

+ log(" pmux2shiftx [options] [selection]\n");

+ log("\n");

+ log("This pass transforms $pmux cells to $shiftx cells.\n");

+ log("\n");

+ log(" -v, -vv\n");

+ log(" verbose output\n");

+ log("\n");

+ log(" -min_density <percentage>\n");

+ log(" specifies the minimum density for the shifter\n");

+ log(" default: 50\n");

+ log("\n");

+ log(" -min_choices <int>\n");

+ log(" specified the minimum number of choices for a control signal\n");

+ log(" default: 3\n");

+ log("\n");

+ log(" -onehot ignore|pmux|shiftx\n");

+ log(" select strategy for one-hot encoded control signals\n");

+ log(" default: pmux\n");

+ log("\n");

+ }

+ void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE

+ {

+ int min_density = 50;

+ int min_choices = 3;

+ bool allow_onehot = false;

+ bool optimize_onehot = true;

+ bool verbose = false;

+ bool verbose_onehot = false;

+

+ log_header(design, "Executing PMUX2SHIFTX pass.\n");

+

+ size_t argidx;

+ for (argidx = 1; argidx < args.size(); argidx++) {

+ if (args[argidx] == "-min_density" && argidx+1 < args.size()) {

+ min_density = atoi(args[++argidx].c_str());

+ continue;

+ }

+ if (args[argidx] == "-min_choices" && argidx+1 < args.size()) {

+ min_choices = atoi(args[++argidx].c_str());

+ continue;

+ }

+ if (args[argidx] == "-onehot" && argidx+1 < args.size() && args[argidx+1] == "ignore") {

+ argidx++;

+ allow_onehot = false;

+ optimize_onehot = false;

+ continue;

+ }

+ if (args[argidx] == "-onehot" && argidx+1 < args.size() && args[argidx+1] == "pmux") {

+ argidx++;

+ allow_onehot = false;

+ optimize_onehot = true;

+ continue;

+ }

+ if (args[argidx] == "-onehot" && argidx+1 < args.size() && args[argidx+1] == "shiftx") {

+ argidx++;

+ allow_onehot = true;

+ optimize_onehot = false;

+ continue;

+ }

+ if (args[argidx] == "-v") {

+ verbose = true;

+ continue;

+ }

+ if (args[argidx] == "-vv") {

+ verbose = true;

+ verbose_onehot = true;

+ continue;

+ }

+ break;

+ }

+ extra_args(args, argidx, design);

+

+ for (auto module : design->selected_modules())

+ {

+ SigMap sigmap(module);

+ OnehotDatabase onehot_db(module, sigmap);

+ onehot_db.verbose = verbose_onehot;

+

+ dict<SigBit, pair<SigSpec, Const>> eqdb;

+

+ for (auto cell : module->cells())

+ {

+ if (cell->type == "$eq")

+ {

+ dict<SigBit, State> bits;

+

+ SigSpec A = sigmap(cell->getPort("\\A"));

+ SigSpec B = sigmap(cell->getPort("\\B"));

+

+ int a_width = cell->getParam("\\A_WIDTH").as_int();

+ int b_width = cell->getParam("\\B_WIDTH").as_int();

+

+ if (a_width < b_width) {

+ bool a_signed = cell->getParam("\\A_SIGNED").as_int();

+ A.extend_u0(b_width, a_signed);

+ }

+

+ if (b_width < a_width) {

+ bool b_signed = cell->getParam("\\B_SIGNED").as_int();

+ B.extend_u0(a_width, b_signed);

+ }

+

+ for (int i = 0; i < GetSize(A); i++) {

+ SigBit a_bit = A[i], b_bit = B[i];

+ if (b_bit.wire && !a_bit.wire) {

+ std::swap(a_bit, b_bit);

+ }

+ if (!a_bit.wire || b_bit.wire)

+ goto next_cell;

+ if (bits.count(a_bit))

+ goto next_cell;

+ bits[a_bit] = b_bit.data;

+ }

+

+ if (GetSize(bits) > 20)

+ goto next_cell;

+

+ bits.sort();

+ pair<SigSpec, Const> entry;

+

+ for (auto it : bits) {

+ entry.first.append_bit(it.first);

+ entry.second.bits.push_back(it.second);

+ }

+

+ eqdb[sigmap(cell->getPort("\\Y")[0])] = entry;

+ goto next_cell;

+ }

+

+ if (cell->type == "$logic_not")

+ {

+ dict<SigBit, State> bits;

+

+ SigSpec A = sigmap(cell->getPort("\\A"));

+

+ for (int i = 0; i < GetSize(A); i++)

+ bits[A[i]] = State::S0;

+

+ bits.sort();

+ pair<SigSpec, Const> entry;

+

+ for (auto it : bits) {

+ entry.first.append_bit(it.first);

+ entry.second.bits.push_back(it.second);

+ }

+

+ eqdb[sigmap(cell->getPort("\\Y")[0])] = entry;

+ goto next_cell;

+ }

+ next_cell:;

+ }

+

+ for (auto cell : module->selected_cells())

+ {

+ if (cell->type != "$pmux")

+ continue;

+

+ string src = cell->get_src_attribute();

+ int width = cell->getParam("\\WIDTH").as_int();

+ int width_bits = ceil_log2(width);

+ int extwidth = width;

+

+ while (extwidth & (extwidth-1))

+ extwidth++;

+

+ dict<SigSpec, pool<int>> seldb;

+

+ SigSpec A = cell->getPort("\\A");

+ SigSpec B = cell->getPort("\\B");

+ SigSpec S = sigmap(cell->getPort("\\S"));

+ for (int i = 0; i < GetSize(S); i++)

+ {

+ if (!eqdb.count(S[i]))

+ continue;

+

+ auto &entry = eqdb.at(S[i]);

+ seldb[entry.first].insert(i);

+ }

+

+ if (seldb.empty())

+ continue;

+

+ bool printed_pmux_header = false;

+

+ if (verbose) {

+ printed_pmux_header = true;

+ log("Inspecting $pmux cell %s/%s.\n", log_id(module), log_id(cell));

+ log(" data width: %d (next power-of-2 = %d, log2 = %d)\n", width, extwidth, width_bits);

+ }

+

+ SigSpec updated_S = cell->getPort("\\S");

+ SigSpec updated_B = cell->getPort("\\B");

+

+ while (!seldb.empty())

+ {

+ // pick the largest entry in seldb

+ SigSpec sig = seldb.begin()->first;

+ for (auto &it : seldb) {

+ if (GetSize(sig) < GetSize(it.first))

+ sig = it.first;

+ else if (GetSize(seldb.at(sig)) < GetSize(it.second))

+ sig = it.first;

+ }

+

+ // find the relevant choices

+ bool is_onehot = GetSize(sig) > 2;

+ dict<Const, int> choices;

+ for (int i : seldb.at(sig)) {

+ Const val = eqdb.at(S[i]).second;

+ int onebits = 0;

+ for (auto b : val.bits)

+ if (b == State::S1)

+ onebits++;

+ if (onebits > 1)

+ is_onehot = false;

+ choices[val] = i;

+ }

+

+ bool full_pmux = GetSize(choices) == GetSize(S);

+

+ // TBD: also find choices that are using signals that are subsets of the bits in "sig"

+

+ if (!verbose)

+ {

+ if (is_onehot && !allow_onehot && !optimize_onehot) {

+ seldb.erase(sig);

+ continue;

+ }

+

+ if (GetSize(choices) < min_choices) {

+ seldb.erase(sig);

+ continue;

+ }

+ }

+

+ if (!printed_pmux_header) {

+ printed_pmux_header = true;

+ log("Inspecting $pmux cell %s/%s.\n", log_id(module), log_id(cell));

+ log(" data width: %d (next power-of-2 = %d, log2 = %d)\n", width, extwidth, width_bits);

+ }

+

+ log(" checking ctrl signal %s\n", log_signal(sig));

+

+ auto print_choices = [&]() {

+ log(" table of choices:\n");

+ for (auto &it : choices)

+ log(" %3d: %s: %s\n", it.second, log_signal(it.first),

+ log_signal(B.extract(it.second*width, width)));

+ };

+

+ if (verbose)

+ {

+ if (is_onehot && !allow_onehot && !optimize_onehot) {

+ print_choices();

+ log(" ignoring one-hot encoding.\n");

+ seldb.erase(sig);

+ continue;

+ }

+

+ if (GetSize(choices) < min_choices) {

+ print_choices();

+ log(" insufficient choices.\n");

+ seldb.erase(sig);

+ continue;

+ }

+ }

+

+ if (is_onehot && optimize_onehot)

+ {

+ print_choices();

+ if (!onehot_db.query(sig))

+ {

+ log(" failed to detect onehot driver. do not optimize.\n");

+ }

+ else

+ {

+ log(" optimizing one-hot encoding.\n");

+ for (auto &it : choices)

+ {

+ const Const &val = it.first;

+ int index = -1;

+

+ for (int i = 0; i < GetSize(val); i++)

+ if (val[i] == State::S1) {

+ log_assert(index < 0);

+ index = i;

+ }

+

+ if (index < 0) {

+ log(" %3d: zero encoding.\n", it.second);

+ continue;

+ }

+

+ SigBit new_ctrl = sig[index];

+ log(" %3d: new crtl signal is %s.\n", it.second, log_signal(new_ctrl));

+ updated_S[it.second] = new_ctrl;

+ }

+ }

+ seldb.erase(sig);

+ continue;

+ }

+

+ // find the best permutation

+ vector<int> perm_new_from_old(GetSize(sig));

+ Const perm_xormask(State::S0, GetSize(sig));

+ {

+ vector<int> values(GetSize(choices));

+ vector<bool> used_src_columns(GetSize(sig));

+ vector<vector<bool>> columns(GetSize(sig), vector<bool>(GetSize(values)));

+

+ for (int i = 0; i < GetSize(choices); i++) {

+ Const val = choices.element(i)->first;

+ for (int k = 0; k < GetSize(val); k++)

+ if (val[k] == State::S1)

+ columns[k][i] = true;

+ }

+

+ for (int dst_col = GetSize(sig)-1; dst_col >= 0; dst_col--)

+ {

+ int best_src_col = -1;

+ bool best_inv = false;

+ int best_maxval = 0;

+ int best_delta = 0;

+

+ // find best src column for this dst column

+ for (int src_col = 0; src_col < GetSize(sig); src_col++)

+ {

+ if (used_src_columns[src_col])

+ continue;

+

+ int this_maxval = 0;

+ int this_minval = 1 << 30;

+

+ int this_inv_maxval = 0;

+ int this_inv_minval = 1 << 30;

+

+ for (int i = 0; i < GetSize(values); i++)

+ {

+ int val = values[i];

+ int inv_val = val;

+

+ if (columns[src_col][i])

+ val |= 1 << dst_col;

+ else

+ inv_val |= 1 << dst_col;

+

+ this_maxval = std::max(this_maxval, val);

+ this_minval = std::min(this_minval, val);

+

+ this_inv_maxval = std::max(this_inv_maxval, inv_val);

+ this_inv_minval = std::min(this_inv_minval, inv_val);

+ }

+

+ int this_delta = this_maxval - this_minval;

+ int this_inv_delta = this_maxval - this_minval;

+ bool this_inv = false;

+

+ if (this_delta != this_inv_delta)

+ this_inv = this_inv_delta < this_delta;

+ else if (this_maxval != this_inv_maxval)

+ this_inv = this_inv_maxval < this_maxval;

+

+ if (this_inv) {

+ this_delta = this_inv_delta;

+ this_maxval = this_inv_maxval;

+ this_minval = this_inv_minval;

+ }

+

+ bool this_is_better = false;

+

+ if (best_src_col < 0)

+ this_is_better = true;

+ else if (this_delta != best_delta)

+ this_is_better = this_delta < best_delta;

+ else if (this_maxval != best_maxval)

+ this_is_better = this_maxval < best_maxval;

+ else

+ this_is_better = sig[best_src_col] < sig[src_col];

+

+ if (this_is_better) {

+ best_src_col = src_col;

+ best_inv = this_inv;

+ best_maxval = this_maxval;

+ best_delta = this_delta;

+ }

+ }

+

+ used_src_columns[best_src_col] = true;

+ perm_new_from_old[dst_col] = best_src_col;

+ perm_xormask[dst_col] = best_inv ? State::S1 : State::S0;

+ }

+ }

+

+ // permutated sig

+ SigSpec perm_sig(State::S0, GetSize(sig));

+ for (int i = 0; i < GetSize(sig); i++)

+ perm_sig[i] = sig[perm_new_from_old[i]];

+

+ log(" best permutation: %s\n", log_signal(perm_sig));

+ log(" best xor mask: %s\n", log_signal(perm_xormask));

+

+ // permutated choices

+ int min_choice = 1 << 30;

+ int max_choice = -1;

+ dict<Const, int> perm_choices;

+

+ for (auto &it : choices)

+ {

+ Const &old_c = it.first;

+ Const new_c(State::S0, GetSize(old_c));

+

+ for (int i = 0; i < GetSize(old_c); i++)

+ new_c[i] = old_c[perm_new_from_old[i]];

+

+ Const new_c_before_xor = new_c;

+ new_c = const_xor(new_c, perm_xormask, false, false, GetSize(new_c));

+

+ perm_choices[new_c] = it.second;

+

+ min_choice = std::min(min_choice, new_c.as_int());

+ max_choice = std::max(max_choice, new_c.as_int());

+

+ log(" %3d: %s -> %s -> %s: %s\n", it.second, log_signal(old_c), log_signal(new_c_before_xor),

+ log_signal(new_c), log_signal(B.extract(it.second*width, width)));

+ }

+

+ int range_density = 100*GetSize(choices) / (max_choice-min_choice+1);

+ int absolute_density = 100*GetSize(choices) / (max_choice+1);

+

+ log(" choices: %d\n", GetSize(choices));

+ log(" min choice: %d\n", min_choice);

+ log(" max choice: %d\n", max_choice);

+ log(" range density: %d%%\n", range_density);

+ log(" absolute density: %d%%\n", absolute_density);

+

+ if (full_pmux) {

+ int full_density = 100*GetSize(choices) / (1 << GetSize(sig));

+ log(" full density: %d%%\n", full_density);

+ if (full_density < min_density) {

+ full_pmux = false;

+ } else {

+ min_choice = 0;

+ max_choice = (1 << GetSize(sig))-1;

+ log(" update to full case.\n");

+ log(" new min choice: %d\n", min_choice);

+ log(" new max choice: %d\n", max_choice);

+ }

+ }

+

+ bool full_case = (min_choice == 0) && (max_choice == (1 << GetSize(sig))-1) && (full_pmux || max_choice+1 == GetSize(choices));

+ log(" full case: %s\n", full_case ? "true" : "false");

+

+ // check density percentages

+ Const offset(State::S0, GetSize(sig));

+ if (absolute_density < min_density && range_density >= min_density)

+ {

+ offset = Const(min_choice, GetSize(sig));

+ log(" offset: %s\n", log_signal(offset));

+

+ min_choice -= offset.as_int();

+ max_choice -= offset.as_int();

+

+ dict<Const, int> new_perm_choices;

+ for (auto &it : perm_choices)

+ new_perm_choices[const_sub(it.first, offset, false, false, GetSize(sig))] = it.second;

+ perm_choices.swap(new_perm_choices);

+ } else

+ if (absolute_density < min_density) {

+ log(" insufficient density.\n");

+ seldb.erase(sig);

+ continue;

+ }

+

+ // creat cmp signal

+ SigSpec cmp = perm_sig;

+ if (perm_xormask.as_bool())

+ cmp = module->Xor(NEW_ID, cmp, perm_xormask, false, src);

+ if (offset.as_bool())

+ cmp = module->Sub(NEW_ID, cmp, offset, false, src);

+

+ // create enable signal

+ SigBit en = State::S1;

+ if (!full_case) {

+ Const enable_mask(State::S0, max_choice+1);

+ for (auto &it : perm_choices)

+ enable_mask[it.first.as_int()] = State::S1;

+ en = module->addWire(NEW_ID);

+ module->addShift(NEW_ID, enable_mask, cmp, en, false, src);

+ }

+

+ // create data signal

+ SigSpec data(State::Sx, (max_choice+1)*extwidth);

+ if (full_pmux) {

+ for (int i = 0; i <= max_choice; i++)

+ data.replace(i*extwidth, A);

+ }

+ for (auto &it : perm_choices) {

+ int position = it.first.as_int()*extwidth;

+ int data_index = it.second;

+ data.replace(position, B.extract(data_index*width, width));

+ updated_S[data_index] = State::S0;

+ updated_B.replace(data_index*width, SigSpec(State::Sx, width));

+ }

+

+ // create shiftx cell

+ SigSpec shifted_cmp = {cmp, SigSpec(State::S0, width_bits)};

+ SigSpec outsig = module->addWire(NEW_ID, width);

+ Cell *c = module->addShiftx(NEW_ID, data, shifted_cmp, outsig, false, src);

+ updated_S.append(en);

+ updated_B.append(outsig);

+ log(" created $shiftx cell %s.\n", log_id(c));

+

+ // remove this sig and continue with the next block

+ seldb.erase(sig);

+ }

+

+ // update $pmux cell

+ cell->setPort("\\S", updated_S);

+ cell->setPort("\\B", updated_B);

+ cell->setParam("\\S_WIDTH", GetSize(updated_S));

+ }

+ }

+ }

+} Pmux2ShiftxPass;

+

+struct OnehotPass : public Pass {

+ OnehotPass() : Pass("onehot", "optimize $eq cells for onehot signals") { }

+ void help() YS_OVERRIDE

+ {

+ // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|

+ log("\n");

+ log(" onehot [options] [selection]\n");

+ log("\n");

+ log("This pass optimizes $eq cells that compare one-hot signals against constants\n");

+ log("\n");

+ log(" -v, -vv\n");

+ log(" verbose output\n");

+ log("\n");

+ }

+ void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE

+ {

+ bool verbose = false;

+ bool verbose_onehot = false;

+

+ log_header(design, "Executing ONEHOT pass.\n");

+

+ size_t argidx;

+ for (argidx = 1; argidx < args.size(); argidx++) {

+ if (args[argidx] == "-v") {

+ verbose = true;

+ continue;

+ }

+ if (args[argidx] == "-vv") {

+ verbose = true;

+ verbose_onehot = true;

+ continue;

+ }

+ break;

+ }

+ extra_args(args, argidx, design);

+

+ for (auto module : design->selected_modules())

+ {

+ SigMap sigmap(module);

+ OnehotDatabase onehot_db(module, sigmap);

+ onehot_db.verbose = verbose_onehot;

+

+ for (auto cell : module->selected_cells())

+ {

+ if (cell->type != "$eq")

+ continue;

+

+ SigSpec A = sigmap(cell->getPort("\\A"));

+ SigSpec B = sigmap(cell->getPort("\\B"));

+

+ int a_width = cell->getParam("\\A_WIDTH").as_int();

+ int b_width = cell->getParam("\\B_WIDTH").as_int();

+

+ if (a_width < b_width) {

+ bool a_signed = cell->getParam("\\A_SIGNED").as_int();

+ A.extend_u0(b_width, a_signed);

+ }

+

+ if (b_width < a_width) {

+ bool b_signed = cell->getParam("\\B_SIGNED").as_int();

+ B.extend_u0(a_width, b_signed);

+ }

+

+ if (A.is_fully_const())

+ std::swap(A, B);

+

+ if (!B.is_fully_const())

+ continue;

+

+ if (verbose)

+ log("Checking $eq(%s, %s) cell %s/%s.\n", log_signal(A), log_signal(B), log_id(module), log_id(cell));

+

+ if (!onehot_db.query(A)) {

+ if (verbose)

+ log(" onehot driver test on %s failed.\n", log_signal(A));

+ continue;

+ }

+

+ int index = -1;

+ bool not_onehot = false;

+

+ for (int i = 0; i < GetSize(B); i++) {

+ if (B[i] != State::S1)

+ continue;

+ if (index >= 0)

+ not_onehot = true;

+ index = i;

+ }

+

+ if (index < 0) {

+ if (verbose)

+ log(" not optimizing the zero pattern.\n");

+ continue;

+ }

+

+ SigSpec Y = cell->getPort("\\Y");

+

+ if (not_onehot)

+ {

+ if (verbose)

+ log(" replacing with constant 0 driver.\n");

+ else

+ log("Replacing one-hot $eq(%s, %s) cell %s/%s with constant 0 driver.\n", log_signal(A), log_signal(B), log_id(module), log_id(cell));

+ module->connect(Y, SigSpec(1, GetSize(Y)));

+ }

+ else

+ {

+ SigSpec sig = A[index];

+ if (verbose)

+ log(" replacing with signal %s.\n", log_signal(sig));

+ else

+ log("Replacing one-hot $eq(%s, %s) cell %s/%s with signal %s.\n",log_signal(A), log_signal(B), log_id(module), log_id(cell), log_signal(sig));

+ sig.extend_u0(GetSize(Y));

+ module->connect(Y, sig);

+ }

+

+ module->remove(cell);

+ }

+ }

+ }

+} OnehotPass;

+

+PRIVATE_NAMESPACE_END

+There is an implicit `code..endcode` block at the end of each `.pmg` file

+ dict<RTLIL::SwitchRule*, pool<RTLIL::SigBit>, hash_ptr_ops> full_case_bits_cache;

+const pool<SigBit> &get_full_case_bits(SnippetSwCache &swcache, RTLIL::SwitchRule *sw)

+{

+ if (!swcache.full_case_bits_cache.count(sw))

+ {

+ pool<SigBit> bits;

+

+ if (sw->get_bool_attribute("\\full_case"))

+ {

+ bool first_case = true;

+

+ for (auto cs : sw->cases)

+ {

+ pool<SigBit> case_bits;

+

+ for (auto it : cs->actions) {

+ for (auto bit : it.first)

+ case_bits.insert(bit);

+ }

+

+ for (auto it : cs->switches) {

+ for (auto bit : get_full_case_bits(swcache, it))

+ case_bits.insert(bit);

+ }

+

+ if (first_case) {

+ first_case = false;

+ bits = case_bits;

+ } else {

+ pool<SigBit> new_bits;

+ for (auto bit : bits)

+ if (case_bits.count(bit))

+ new_bits.insert(bit);

+ bits.swap(new_bits);

+ }

+ }

+ }

+

+ bits.swap(swcache.full_case_bits_cache[sw]);

+ }

+

+ return swcache.full_case_bits_cache.at(sw);

+}

+

+ // mask default bits that are irrelevant because the output is driven by a full case

+ const pool<SigBit> &full_case_bits = get_full_case_bits(swcache, sw);

+ for (int i = 0; i < GetSize(sig); i++)

+ if (full_case_bits.count(sig[i]))

+ result[i] = State::Sx;

+

+void proc_rmdead(RTLIL::SwitchRule *sw, int &counter, int &full_case_counter)

+ proc_rmdead(switch_it, counter, full_case_counter);

+

+ if (pool.empty() && !sw->get_bool_attribute("\\full_case")) {

+ sw->set_bool_attribute("\\full_case");

+ full_case_counter++;

+ }

+ int counter = 0, full_case_counter = 0;

+ proc_rmdead(switch_it, counter, full_case_counter);

+ log_id(proc_it.first), log_id(mod));

+ if (full_case_counter > 0)

+ log("Marked %d switch rules as full_case in process %s in module %s.\n",

+ full_case_counter, log_id(proc_it.first), log_id(mod));

+ Pass::call_on_module(design, miter_module, "flatten -wb; opt_expr -keepdc -undriven;;");

+ Pass::call_on_module(design, module, "flatten -wb;;");

+ log(" call 'flatten -wb; opt_expr -keepdc -undriven;;' on the miter circuit.\n");

+ log(" call 'flatten -wb; opt_expr -keepdc -undriven;;' on the miter circuit.\n");

+#define ABC_COMMAND_LIB "strash; ifraig; scorr; dc2; dretime; retime {D}; strash; &get -n; &dch -f; &nf {D}; &put"

+#define ABC_COMMAND_CTR "strash; ifraig; scorr; dc2; dretime; retime {D}; strash; &get -n; &dch -f; &nf {D}; &put; buffer; upsize {D}; dnsize {D}; stime -p"

+#define ABC_COMMAND_LUT "strash; ifraig; scorr; dc2; dretime; retime {D}; strash; dch -f; if; mfs2"

+#define ABC_COMMAND_SOP "strash; ifraig; scorr; dc2; dretime; retime {D}; strash; dch -f; cover {I} {P}"

+#define ABC_COMMAND_DFL "strash; ifraig; scorr; dc2; dretime; retime {D}; strash; &get -n; &dch -f; &nf {D}; &put"

+

+#define ABC_FAST_COMMAND_LIB "strash; dretime; retime {D}; map {D}"

+#define ABC_FAST_COMMAND_CTR "strash; dretime; retime {D}; map {D}; buffer; upsize {D}; dnsize {D}; stime -p"

+#define ABC_FAST_COMMAND_LUT "strash; dretime; retime {D}; if"

+#define ABC_FAST_COMMAND_SOP "strash; dretime; retime {D}; cover -I {I} -P {P}"

+#define ABC_FAST_COMMAND_DFL "strash; dretime; retime {D}; map"

+ if (inv) abc_sname.pop_back();

+ abc_sname.erase(0, 5);

+ if (abc_sname.find_last_not_of("012345689") == std::string::npos) {

+ int sid = std::stoi(abc_sname);

+ for (auto sig : signal_list) {

+ if (sig.id == sid && sig.bit.wire != nullptr) {

+ std::stringstream sstr;

+ sstr << "$abc$" << map_autoidx << "$" << sig.bit.wire->name.substr(1);

+ if (sig.bit.wire->width != 1)

+ sstr << "[" << sig.bit.offset << "]";

+ if (inv)

+ sstr << "_inv";

+ if (orig_wire != nullptr)

+ *orig_wire = sig.bit.wire;

+ return sstr.str();

+ }

+ signal_init[initsig[i]] = State::S1;

+ bool has_value;

+ return !(match_name(name, id) && (!has_value || match_value(value, val)));

+ action->has_value = (p != string::npos);

+ if (design->selected(it.second) && !it.second->get_blackbox_attribute())

+ log(" pmuxtree [selection]\n");

+ log("This pass transforms $pmux cells to trees of $mux cells.\n");

+ virtual void init(const Module * /*module*/, const SigMap &/*sigmap*/) {}

+ virtual void non_chain_user(const SigBit &/*bit*/, const Cell* /*cell*/, IdString /*port*/) {}

+ virtual bool analyze(vector<int> &taps, const vector<SigBit> &qbits) = 0;

+ bool analyze(vector<int> &taps, const vector<SigBit> &/*qbits*/)

+struct ShregmapTechXilinx7 : ShregmapTech

+{

+ dict<SigBit, std::tuple<Cell*,int,int>> sigbit_to_shiftx_offset;

+ const ShregmapOptions &opts;

+

+ ShregmapTechXilinx7(const ShregmapOptions &opts) : opts(opts) {}

+

+ virtual void init(const Module* module, const SigMap &sigmap) override

+ {

+ for (const auto &i : module->cells_) {

+ auto cell = i.second;

+ if (cell->type == "$shiftx") {

+ if (cell->getParam("\\Y_WIDTH") != 1) continue;

+ int j = 0;

+ for (auto bit : sigmap(cell->getPort("\\A")))

+ sigbit_to_shiftx_offset[bit] = std::make_tuple(cell, j++, 0);

+ log_assert(j == cell->getParam("\\A_WIDTH").as_int());

+ }

+ else if (cell->type == "$mux") {

+ int j = 0;

+ for (auto bit : sigmap(cell->getPort("\\A")))

+ sigbit_to_shiftx_offset[bit] = std::make_tuple(cell, 0, j++);

+ j = 0;

+ for (auto bit : sigmap(cell->getPort("\\B")))

+ sigbit_to_shiftx_offset[bit] = std::make_tuple(cell, 1, j++);

+ }

+ }

+ }

+

+ virtual void non_chain_user(const SigBit &bit, const Cell *cell, IdString port) override

+ {

+ auto it = sigbit_to_shiftx_offset.find(bit);

+ if (it == sigbit_to_shiftx_offset.end())

+ return;

+ if (cell) {

+ if (cell->type == "$shiftx" && port == "\\A")

+ return;

+ if (cell->type == "$mux" && (port == "\\A" || port == "\\B"))

+ return;

+ }

+ sigbit_to_shiftx_offset.erase(it);

+ }

+

+ virtual bool analyze(vector<int> &taps, const vector<SigBit> &qbits) override

+ {

+ if (GetSize(taps) == 1)

+ return taps[0] >= opts.minlen-1 && sigbit_to_shiftx_offset.count(qbits[0]);

+

+ if (taps.back() < opts.minlen-1)

+ return false;

+

+ Cell *shiftx = nullptr;

+ int group = 0;

+ for (int i = 0; i < GetSize(taps); ++i) {

+ auto it = sigbit_to_shiftx_offset.find(qbits[i]);

+ if (it == sigbit_to_shiftx_offset.end())

+ return false;

+

+ // Check taps are sequential

+ if (i != taps[i])

+ return false;

+ // Check taps are not connected to a shift register,

+ // or sequential to the same shift register

+ if (i == 0) {

+ int offset;

+ std::tie(shiftx,offset,group) = it->second;

+ if (offset != i)

+ return false;

+ }

+ else {

+ Cell *shiftx_ = std::get<0>(it->second);

+ if (shiftx_ != shiftx)

+ return false;

+ int offset = std::get<1>(it->second);

+ if (offset != i)

+ return false;

+ int group_ = std::get<2>(it->second);

+ if (group_ != group)

+ return false;

+ }

+ }

+ log_assert(shiftx);

+

+ // Only map if $shiftx exclusively covers the shift register

+ if (shiftx->type == "$shiftx") {

+ if (GetSize(taps) != shiftx->getParam("\\A_WIDTH").as_int())

+ return false;

+ }

+ else if (shiftx->type == "$mux") {

+ if (GetSize(taps) != 2)

+ return false;

+ }

+ else log_abort();

+

+ return true;

+ }

+

+ virtual bool fixup(Cell *cell, dict<int, SigBit> &taps) override

+ {

+ const auto &tap = *taps.begin();

+ auto bit = tap.second;

+

+ auto it = sigbit_to_shiftx_offset.find(bit);

+ log_assert(it != sigbit_to_shiftx_offset.end());

+

+ auto newcell = cell->module->addCell(NEW_ID, "$__XILINX_SHREG_");

+ newcell->set_src_attribute(cell->get_src_attribute());

+ newcell->setParam("\\DEPTH", cell->getParam("\\DEPTH"));

+ newcell->setParam("\\INIT", cell->getParam("\\INIT"));

+ newcell->setParam("\\CLKPOL", cell->getParam("\\CLKPOL"));

+ newcell->setParam("\\ENPOL", cell->getParam("\\ENPOL"));

+

+ newcell->setPort("\\C", cell->getPort("\\C"));

+ newcell->setPort("\\D", cell->getPort("\\D"));

+ if (cell->hasPort("\\E"))

+ newcell->setPort("\\E", cell->getPort("\\E"));

+

+ Cell* shiftx = std::get<0>(it->second);

+ RTLIL::SigSpec l_wire, q_wire;

+ if (shiftx->type == "$shiftx") {

+ l_wire = shiftx->getPort("\\B");

+ q_wire = shiftx->getPort("\\Y");

+ shiftx->setPort("\\Y", cell->module->addWire(NEW_ID));

+ }

+ else if (shiftx->type == "$mux") {

+ l_wire = shiftx->getPort("\\S");

+ q_wire = shiftx->getPort("\\Y");

+ shiftx->setPort("\\Y", cell->module->addWire(NEW_ID));

+ }

+ else log_abort();

+

+ newcell->setPort("\\Q", q_wire);

+ newcell->setPort("\\L", l_wire);

+

+ return false;

+ }

+};

+

+

+ for (auto bit : sigmap(wire)) {

+ if (opts.tech) opts.tech->non_chain_user(bit, nullptr, {});

+ }

+ for (auto bit : sigmap(conn.second)) {

+ if (opts.tech) opts.tech->non_chain_user(bit, cell, conn.first);

+ }

+ if (opts.tech->analyze(taps, qbits))

+ if (opts.tech)

+ opts.tech->init(module, sigmap);

+

+ }

+ else if (tech == "xilinx") {

+ opts.init = true;

+ opts.params = true;

+ enpol = "any_or_none";

+ opts.tech = new ShregmapTechXilinx7(opts);

+ if (!design->selected(mod) || mod->get_blackbox_attribute())

+ pool<string> log_msg_cache;

+

+ bool ignore_wb;

+ ignore_wb = false;

+ if (!design->selected(module) || module->get_blackbox_attribute(ignore_wb))

+ LogMakeDebugHdl mkdebug;

+ if (tpl->get_blackbox_attribute(ignore_wb))

+ mkdebug.on();

+ auto msg = stringf("Using extmapper %s for cells of type %s.", log_id(extmapper_module), log_id(cell->type));

+ if (!log_msg_cache.count(msg)) {

+ log_msg_cache.insert(msg);

+ log("%s\n", msg.c_str());

+ }

+ log_debug("%s %s.%s (%s) to %s.\n", mapmsg_prefix.c_str(), log_id(module), log_id(cell), log_id(cell->type), log_id(extmapper_module));

+ auto msg = stringf("Using extmapper %s for cells of type %s.", extmapper_name.c_str(), log_id(cell->type));

+ if (!log_msg_cache.count(msg)) {

+ log_msg_cache.insert(msg);

+ log("%s\n", msg.c_str());

+ }

+ log_debug("%s %s.%s (%s) with %s.\n", mapmsg_prefix.c_str(), log_id(module), log_id(cell), log_id(cell->type), extmapper_name.c_str());

+ mkdebug.on();

+ mkdebug.off();

+ mkdebug.off();

+ log_debug("%s %s.%s to imported %s.\n", mapmsg_prefix.c_str(), log_id(module), log_id(cell), log_id(m_name));

+ auto msg = stringf("Using template %s for cells of type %s.", log_id(tpl), log_id(cell->type));

+ if (!log_msg_cache.count(msg)) {

+ log_msg_cache.insert(msg);

+ log("%s\n", msg.c_str());

+ }

+ log_debug("%s %s.%s (%s) using %s.\n", mapmsg_prefix.c_str(), log_id(module), log_id(cell), log_id(cell->type), log_id(tpl));

+ mkdebug.off();

+ log(" -wb\n");

+ log(" Ignore the 'whitebox' attribute on cell implementations.\n");

+ log("\n");

+ std::string verilog_frontend = "verilog -nooverwrite -noblackbox";

+ if (args[argidx] == "-wb") {

+ worker.ignore_wb = true;

+ continue;

+ }

+ } else {

+ }

+

+ log_header(design, "Continuing TECHMAP pass.\n");

+ log(" flatten [options] [selection]\n");

+ log(" -wb\n");

+ log(" Ignore the 'whitebox' attribute on cell implementations.\n");

+ log("\n");

+ size_t argidx;

+ for (argidx = 1; argidx < args.size(); argidx++) {

+ if (args[argidx] == "-wb") {

+ worker.ignore_wb = true;

+ continue;

+ }

+ break;

+ }

+ extra_args(args, argidx, design);

+

+

+ log_suppressed();

+ if (used_modules[mod->name] || mod->get_blackbox_attribute(worker.ignore_wb)) {

+ run("opt_expr -undriven -mux_undef");

+OBJS += techlibs/gowin/determine_init.o

+

+$(eval $(call add_share_file,share/gowin,techlibs/gowin/brams_map.v))

+$(eval $(call add_share_file,share/gowin,techlibs/gowin/bram.txt))

+$(eval $(call add_share_file,share/gowin,techlibs/gowin/drams_map.v))

+$(eval $(call add_share_file,share/gowin,techlibs/gowin/dram.txt))

+

+

+

+$(eval $(call add_share_file,share/gowin,techlibs/gowin/brams_init3.vh))

+bram $__GW1NR_SDP

+# uncomment when done

+# init 1

+ abits 10 @a10d18

+ dbits 16 @a10d18

+ abits 11 @a11d9

+ dbits 8 @a11d9

+ abits 12 @a12d4

+ dbits 4 @a12d4

+ abits 13 @a13d2

+ dbits 2 @a13d2

+ abits 14 @a14d1

+ dbits 1 @a14d1

+ groups 2

+ ports 1 1

+ wrmode 1 0

+ enable 1 1 @a10d18

+ enable 1 1 @a11d9 @a12d4 @a13d2 @a14d1

+ transp 0 0

+ clocks 2 3

+ clkpol 2 3

+endbram

+

+match $__GW1NR_SDP

+ min bits 2048

+ min efficiency 5

+ shuffle_enable B

+ make_transp

+endmatch

+localparam [15:0] INIT_0 = {

+ INIT[ 60], INIT[ 56], INIT[ 52], INIT[ 48], INIT[ 44], INIT[ 40], INIT[ 36], INIT[ 32], INIT[ 28], INIT[ 24], INIT[ 20], INIT[ 16], INIT[ 12], INIT[ 8], INIT[ 4], INIT[ 0]

+};

+localparam [15:0] INIT_1 = {

+ INIT[ 61], INIT[ 57], INIT[ 53], INIT[ 49], INIT[ 45], INIT[ 41], INIT[ 37], INIT[ 33], INIT[ 29], INIT[ 25], INIT[ 21], INIT[ 17], INIT[ 13], INIT[ 9], INIT[ 5], INIT[ 1]

+};

+localparam [15:0] INIT_2 = {

+ INIT[ 62], INIT[ 58], INIT[ 54], INIT[ 50], INIT[ 46], INIT[ 42], INIT[ 38], INIT[ 34], INIT[ 30], INIT[ 26], INIT[ 22], INIT[ 18], INIT[ 14], INIT[ 10], INIT[ 6], INIT[ 2]

+};

+localparam [15:0] INIT_3 = {

+ INIT[ 63], INIT[ 59], INIT[ 55], INIT[ 51], INIT[ 47], INIT[ 43], INIT[ 39], INIT[ 35], INIT[ 31], INIT[ 27], INIT[ 23], INIT[ 19], INIT[ 15], INIT[ 11], INIT[ 7], INIT[ 3]

+};

+/* Semi Dual Port (SDP) memory have the following configurations:

+ * Memory Config RAM(BIT) Port Mode Memory Depth Data Depth

+ * ----------------|---------| ----------|--------------|------------|

+ * B-SRAM_16K_SD1 16K 16Kx1 16,384 1

+ * B-SRAM_8K_SD2 16K 8Kx2 8,192 2

+ * B-SRAM_4K_SD4 16K 4Kx2 4,096 4

+ */

+module \$__GW1NR_SDP (CLK2, CLK3, A1ADDR, A1DATA, A1EN, B1ADDR, B1DATA, B1EN);

+ parameter CFG_ABITS = 10;

+ parameter CFG_DBITS = 16;

+ parameter CFG_ENABLE_A = 3;

+

+ parameter [16383:0] INIT = 16384'hx;

+ parameter CLKPOL2 = 1;

+ parameter CLKPOL3 = 1;

+

+ input CLK2;

+ input CLK3;

+

+ input [CFG_ABITS-1:0] A1ADDR;

+ input [CFG_DBITS-1:0] A1DATA;

+ input [CFG_ENABLE_A-1:0] A1EN;

+

+ input [CFG_ABITS-1:0] B1ADDR;

+ output [CFG_DBITS-1:0] B1DATA;

+ input B1EN;

+

+

+ generate if (CFG_DBITS == 1) begin

+ SDP #(

+ .READ_MODE(0),

+ .BIT_WIDTH_0(1),

+ .BIT_WIDTH_1(1),

+ .BLK_SEL(3'b000),

+ .RESET_MODE("SYNC")

+ ) _TECHMAP_REPLACE_ (

+ .CLKA(CLK2), .CLKB(CLK3),

+ .WREA(A1EN), .OCE(1'b0), .CEA(1'b1),

+ .WREB(1'b0), .CEB(B1EN),

+ .RESETA(1'b0), .RESETB(1'b0), .BLKSEL(3'b000),

+ .DI(A1DATA), .DO(B1DATA), .ADA(A1ADDR), .ADB(B1ADDR)

+ );

+ end else if (CFG_DBITS == 2) begin

+ SDP #(

+ .READ_MODE(0),

+ .BIT_WIDTH_0(2),

+ .BIT_WIDTH_1(2),

+ .BLK_SEL(3'b000),

+ .RESET_MODE("SYNC")

+ ) _TECHMAP_REPLACE_ (

+ .CLKA(CLK2), .CLKB(CLK3),

+ .WREA(A1EN), .OCE(1'b0), .CEA(1'b1),

+ .WREB(1'b0), .CEB(B1EN),

+ .RESETA(1'b0), .RESETB(1'b0), .BLKSEL(3'b000),

+ .DI(A1DATA), .DO(B1DATA), .ADA(A1ADDR), .ADB(B1ADDR)

+ );

+ end else if (CFG_DBITS <= 4) begin

+ SDP #(

+ .READ_MODE(0),

+ .BIT_WIDTH_0(4),

+ .BIT_WIDTH_1(4),

+ .BLK_SEL(3'b000),

+ .RESET_MODE("SYNC")

+ ) _TECHMAP_REPLACE_ (

+ .CLKA(CLK2), .CLKB(CLK3),

+ .WREA(A1EN), .OCE(1'b0),

+ .WREB(1'b0), .CEB(B1EN), .CEA(1'b1),

+ .RESETA(1'b0), .RESETB(1'b0), .BLKSEL(3'b000),

+ .DI(A1DATA), .DO(B1DATA), .ADA(A1ADDR), .ADB(B1ADDR)

+ );

+ end else if (CFG_DBITS <= 8) begin

+ SDP #(

+ .READ_MODE(0),

+ .BIT_WIDTH_0(8),

+ .BIT_WIDTH_1(8),

+ .BLK_SEL(3'b000),

+ .RESET_MODE("SYNC")

+ ) _TECHMAP_REPLACE_ (

+ .CLKA(CLK2), .CLKB(CLK3),

+ .WREA(A1EN), .OCE(1'b0), .CEA(1'b1),

+ .WREB(1'b0), .CEB(B1EN),

+ .RESETA(1'b0), .RESETB(1'b0), .BLKSEL(3'b000),

+ .DI(A1DATA), .DO(B1DATA), .ADA(A1ADDR), .ADB(B1ADDR)

+ );

+ end else if (CFG_DBITS <= 16) begin

+ SDP #(

+ .READ_MODE(0),

+ .BIT_WIDTH_0(16),

+ .BIT_WIDTH_1(16),

+ .BLK_SEL(3'b000),

+ .RESET_MODE("SYNC")

+ ) _TECHMAP_REPLACE_ (

+ .CLKA(CLK2), .CLKB(CLK3),

+ .WREA(A1EN), .OCE(1'b0),

+ .WREB(1'b0), .CEB(B1EN), .CEA(1'b1),

+ .RESETA(1'b0), .RESETB(1'b0), .BLKSEL(3'b000),

+ .DI(A1DATA), .DO(B1DATA), .ADA(A1ADDR), .ADB(B1ADDR)

+ );

+ end else begin

+ wire TECHMAP_FAIL = 1'b1;

+ end endgenerate

+

+endmodule

+module \$_DFF_P_ #(parameter INIT = 1'b0) (input D, C, output Q); DFF #(.INIT(INIT)) _TECHMAP_REPLACE_ (.D(D), .Q(Q), .CLK(C)); endmodule

+

+module \$__DFFS_PN0_ (input D, C, R, output Q); DFFR _TECHMAP_REPLACE_ (.D(D), .Q(Q), .CLK(C), .RESET(!R)); endmodule

+module \$__DFFS_PP0_ (input D, C, R, output Q); DFFR _TECHMAP_REPLACE_ (.D(D), .Q(Q), .CLK(C), .RESET(R)); endmodule

+module \$__DFFS_PP1_ (input D, C, R, output Q); DFFR _TECHMAP_REPLACE_ (.D(D), .Q(Q), .CLK(C), .RESET(R)); endmodule

+module DFFR (output reg Q, input D, CLK, RESET);

+ parameter [0:0] INIT = 1'b0;

+ initial Q = INIT;

+ always @(posedge CLK) begin

+ if (RESET)

+ Q <= 1'b0;

+ else

+ Q <= D;

+ end

+endmodule // DFFR (positive clock edge; synchronous reset)

+