Merge branch 'master' into gqtech

6 files changed, 367 insertions, 127 deletions

diff --git a/common/design.cc b/common/design.cc
index 7ba6a9b1..6ab122df 100644
--- a/common/design.cc
+++ b/common/design.cc
@@ -18,4 +18,3 @@
  */
 
 #include "design.h"
-
diff --git a/common/design.h b/common/design.h
index 314c2fd7..f4c24f15 100644
--- a/common/design.h
+++ b/common/design.h
@@ -20,50 +20,52 @@
 #ifndef DESIGN_H
 #define DESIGN_H
 
-#include <stdint.h>
 #include <assert.h>
-#include <vector>
+#include <stdint.h>
 #include <string>
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 // replace with proper IdString later
 typedef std::string IdString;
 
 // replace with haslib later
-template<typename T> using pool = std::unordered_set<T>;
-template<typename T, typename U> using dict = std::unordered_map<T, U>;
+template <typename T> using pool = std::unordered_set<T>;
+template <typename T, typename U> using dict = std::unordered_map<T, U>;
 using std::vector;
 
 struct GraphicElement
 {
-	// This will control colour, and there should be separate
-	// visibility controls in some cases also
-	enum {
-		// Wires entirely inside tiles, e.g. between switchbox and bels
-		G_LOCAL_WIRES,
-		// Standard inter-tile routing
-		G_GENERAL_WIRES,
-		// Special inter-tile wires, e.g. carry chains
-		G_DEDICATED_WIRES,
-		G_BEL_OUTLINE,
-		G_SWITCHBOX_OUTLINE,
-		G_TILE_OUTLINE,
-		G_BEL_PINS,
-		G_SWITCHBOX_PINS,
-		G_BEL_MISC,
-		G_TILE_MISC,
-	} style;
-
-	enum {
-		G_LINE,
-		G_BOX,
-		G_CIRCLE,
-		G_LABEL
-	} type;
-
-	float x1, y1, x2, y2, z;
-	std::string text;
+    // This will control colour, and there should be separate
+    // visibility controls in some cases also
+    enum
+    {
+        // Wires entirely inside tiles, e.g. between switchbox and bels
+        G_LOCAL_WIRES,
+        // Standard inter-tile routing
+        G_GENERAL_WIRES,
+        // Special inter-tile wires, e.g. carry chains
+        G_DEDICATED_WIRES,
+        G_BEL_OUTLINE,
+        G_SWITCHBOX_OUTLINE,
+        G_TILE_OUTLINE,
+        G_BEL_PINS,
+        G_SWITCHBOX_PINS,
+        G_BEL_MISC,
+        G_TILE_MISC,
+    } style;
+
+    enum
+    {
+        G_LINE,
+        G_BOX,
+        G_CIRCLE,
+        G_LABEL
+    } type;
+
+    float x1, y1, x2, y2, z;
+    std::string text;
 };
 
 #include "chip.h"
@@ -72,56 +74,57 @@ struct CellInfo;
 
 struct PortRef
 {
-	CellInfo *cell;
-	IdString port;
+    CellInfo *cell;
+    IdString port;
 };
 
 struct NetInfo
 {
-	IdString			name;
-	PortRef				driver;
-	vector<PortRef>			users;
-	dict<IdString, std::string>	attrs;
+    IdString name;
+    PortRef driver;
+    vector<PortRef> users;
+    dict<IdString, std::string> attrs;
 
-	// wire -> (uphill_wire, delay)
-	dict<WireId, std::pair<WireId, DelayInfo>>	wires;
+    // wire -> (uphill_wire, delay)
+    dict<WireId, std::pair<WireId, DelayInfo>> wires;
 };
 
 enum PortType
 {
-	PORT_IN = 0,
-	PORT_OUT = 1,
-	PORT_INOUT = 2
+    PORT_IN = 0,
+    PORT_OUT = 1,
+    PORT_INOUT = 2
 };
 
 struct PortInfo
 {
-	IdString name;
-	NetInfo *net;
-	PortType type;
+    IdString name;
+    NetInfo *net;
+    PortType type;
 };
 
 struct CellInfo
 {
-	IdString			name, type;
-	dict<IdString, PortInfo>	ports;
-	dict<IdString, std::string>	attrs, params;
+    IdString name, type;
+    dict<IdString, PortInfo> ports;
+    dict<IdString, std::string> attrs, params;
 
-	BelId bel;
-	// cell_port -> bel_pin
-	dict<IdString, IdString>	pins;
+    BelId bel;
+    // cell_port -> bel_pin
+    dict<IdString, IdString> pins;
 };
 
 struct Design
 {
-	struct Chip chip;
+    struct Chip chip;
 
-	Design(ChipArgs args) : chip(args) {
-		// ...
-	}
+    Design(ChipArgs args) : chip(args)
+    {
+        // ...
+    }
 
-	dict<IdString, NetInfo*>	nets;
-	dict<IdString, CellInfo*>	cells;
+    dict<IdString, NetInfo *> nets;
+    dict<IdString, CellInfo *> cells;
 };
 
 #endif
diff --git a/common/pybindings.cc b/common/pybindings.cc
index 556e838e..5c86720e 100644
--- a/common/pybindings.cc
+++ b/common/pybindings.cc
@@ -18,24 +18,89 @@
  *
  */
 
-
-#include "design.h"
 #include "chip.h"
+#include "design.h"
+#include "emb.h"
+
+// include after design.h/chip.h
 #include "pybindings.h"
 
-// Required to determine concatenated module name (which differs for different archs)
-#define PASTER(x, y) x ## _ ## y
-#define EVALUATOR(x, y)  PASTER(x,y)
+// Required to determine concatenated module name (which differs for different
+// archs)
+#define PASTER(x, y) x##_##y
+#define EVALUATOR(x, y) PASTER(x, y)
 #define MODULE_NAME EVALUATOR(nextpnrpy, ARCHNAME)
 #define PYINIT_MODULE_NAME EVALUATOR(&PyInit_nextpnrpy, ARCHNAME)
 #define STRINGIFY(x) #x
 #define TOSTRING(x) STRINGIFY(x)
 
-// Architecture-specific bindings should be created in the below function, which must be implemented in all
-// architectures
+// Architecture-specific bindings should be created in the below function, which
+// must be implemented in all architectures
 void arch_wrap_python();
 
-BOOST_PYTHON_MODULE (MODULE_NAME) {
+bool operator==(const PortRef &a, const PortRef &b)
+{
+    return (a.cell == b.cell) && (a.port == b.port);
+}
+
+BOOST_PYTHON_MODULE(MODULE_NAME)
+{
+    class_<GraphicElement>("GraphicElement")
+            .def_readwrite("style", &GraphicElement::style)
+            .def_readwrite("type", &GraphicElement::type)
+            .def_readwrite("x1", &GraphicElement::x1)
+            .def_readwrite("y1", &GraphicElement::y1)
+            .def_readwrite("x2", &GraphicElement::x2)
+            .def_readwrite("y2", &GraphicElement::y2)
+            .def_readwrite("text", &GraphicElement::text);
+
+    class_<PortRef>("PortRef")
+            .def_readwrite("cell", &PortRef::cell)
+            .def_readwrite("port", &PortRef::port);
+
+    class_<NetInfo, NetInfo *>("NetInfo")
+            .def_readwrite("name", &NetInfo::name)
+            .def_readwrite("driver", &NetInfo::driver)
+            .def_readwrite("users", &NetInfo::users)
+            .def_readwrite("attrs", &NetInfo::attrs)
+            .def_readwrite("wires", &NetInfo::wires);
+
+    WRAP_MAP(decltype(NetInfo::attrs), "IdStrMap");
+
+    class_<vector<PortRef>>("PortRefVector")
+            .def(vector_indexing_suite<vector<PortRef>>());
+
+    enum_<PortType>("PortType")
+            .value("PORT_IN", PORT_IN)
+            .value("PORT_OUT", PORT_OUT)
+            .value("PORT_INOUT", PORT_INOUT)
+            .export_values();
+
+    class_<PortInfo>("PortInfo")
+            .def_readwrite("name", &PortInfo::name)
+            .def_readwrite("net", &PortInfo::net)
+            .def_readwrite("type", &PortInfo::type);
+
+    class_<CellInfo, CellInfo *>("CellInfo")
+            .def_readwrite("name", &CellInfo::name)
+            .def_readwrite("type", &CellInfo::type)
+            .def_readwrite("ports", &CellInfo::ports)
+            .def_readwrite("attrs", &CellInfo::attrs)
+            .def_readwrite("params", &CellInfo::params)
+            .def_readwrite("bel", &CellInfo::bel)
+            .def_readwrite("pins", &CellInfo::pins);
+
+    WRAP_MAP(decltype(CellInfo::ports), "IdPortMap");
+    // WRAP_MAP(decltype(CellInfo::pins), "IdIdMap");
+
+    class_<Design, Design *>("Design", no_init)
+            .def_readwrite("chip", &Design::chip)
+            .def_readwrite("nets", &Design::nets)
+            .def_readwrite("cells", &Design::cells);
+
+    WRAP_MAP(decltype(Design::nets), "IdNetMap");
+    WRAP_MAP(decltype(Design::cells), "IdCellMap");
+
     arch_wrap_python();
 }
 
@@ -44,35 +109,47 @@ void arch_appendinittab()
     PyImport_AppendInittab(TOSTRING(MODULE_NAME), PYINIT_MODULE_NAME);
 }
 
-void execute_python_file(const char *executable, const char* python_file)
+static wchar_t *program;
+
+void init_python(const char *executable)
 {
-    wchar_t *program = Py_DecodeLocale(executable, NULL);
+    program = Py_DecodeLocale(executable, NULL);
     if (program == NULL) {
         fprintf(stderr, "Fatal error: cannot decode executable filename\n");
         exit(1);
     }
-    try 
-    {		
+    try {
         PyImport_AppendInittab(TOSTRING(MODULE_NAME), PYINIT_MODULE_NAME);
+        emb::append_inittab();
         Py_SetProgramName(program);
         Py_Initialize();
+        PyImport_ImportModule(TOSTRING(MODULE_NAME));
+    } catch (boost::python::error_already_set const &) {
+        // Parse and output the exception
+        std::string perror_str = parse_python_exception();
+        std::cout << "Error in Python: " << perror_str << std::endl;
+    }
+}
+
+void deinit_python()
+{
+    Py_Finalize();
+    PyMem_RawFree(program);
+}
 
-        FILE* fp = fopen(python_file, "r");	
+void execute_python_file(const char *python_file)
+{
+    try {
+        FILE *fp = fopen(python_file, "r");
         if (fp == NULL) {
-            fprintf(stderr, "Fatal error: file not found %s\n",python_file);
+            fprintf(stderr, "Fatal error: file not found %s\n", python_file);
             exit(1);
         }
-        PyRun_SimpleFile(fp , python_file);
+        PyRun_SimpleFile(fp, python_file);
         fclose(fp);
-
-        Py_Finalize();
-        PyMem_RawFree(program);
-    } 
-    catch(boost::python::error_already_set const &)
-    {
+    } catch (boost::python::error_already_set const &) {
         // Parse and output the exception
         std::string perror_str = parse_python_exception();
         std::cout << "Error in Python: " << perror_str << std::endl;
     }
 }
-
diff --git a/common/pybindings.h b/common/pybindings.h
index f594784c..bb060718 100644
--- a/common/pybindings.h
+++ b/common/pybindings.h
@@ -20,67 +20,98 @@
 
 #ifndef COMMON_PYBINDINGS_H
 #define COMMON_PYBINDINGS_H
-#include <utility>
-#include <stdexcept>
+
+#include "pycontainers.h"
+
+#include <Python.h>
 #include <boost/python.hpp>
-#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
-#include <boost/python/suite/indexing/map_indexing_suite.hpp>
 #include <boost/python/suite/indexing/map_indexing_suite.hpp>
-
+#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
+#include <stdexcept>
+#include <utility>
 using namespace boost::python;
+
 /*
-A wrapper for a Pythonised nextpnr Iterator. The actual class wrapped is a
-pair<Iterator, Iterator> containing (current, end)
-*/
-
-template<typename T>
-struct iterator_wrapper {
-    typedef decltype(*(std::declval<T>())) value_t;
-
-    static value_t next(std::pair<T, T> &iter) {
-        if (iter.first != iter.second) {
-            value_t val = *iter.first;
-            ++iter.first;
-            return val;
-        } else {
-            PyErr_SetString(PyExc_StopIteration, "End of range reached");
-            boost::python::throw_error_already_set();
-            // Should be unreachable, but prevent control may reach end of non-void
-            throw std::runtime_error("unreachable");
+A wrapper to enable custom type/ID to/from string conversions
+ */
+template <typename T> struct string_wrapper
+{
+    template <typename F> struct from_pystring_converter
+    {
+        from_pystring_converter()
+        {
+            converter::registry::push_back(&convertible, &construct,
+                                           boost::python::type_id<T>());
+        };
+
+        static void *convertible(PyObject *object)
+        {
+            return PyUnicode_Check(object) ? object : 0;
         }
-    }
 
-    static void wrap(const char *python_name) {
-        class_<std::pair<T, T>>(python_name, no_init)
-                .def("__next__", next);
-    }
-};
+        static void construct(PyObject *object,
+                              converter::rvalue_from_python_stage1_data *data)
+        {
+            const wchar_t *value = PyUnicode_AsUnicode(object);
+            const std::wstring value_ws(value);
+            if (value == 0)
+                throw_error_already_set();
+            void *storage =
+                    ((boost::python::converter::rvalue_from_python_storage<T> *)
+                             data)
+                            ->storage.bytes;
+            new (storage) T(fn(std::string(value_ws.begin(), value_ws.end())));
+            data->convertible = storage;
+        }
 
-/*
-A wrapper for a nextpnr Range. Ranges should have two functions, begin()
-and end() which return iterator-like objects supporting ++, * and !=
-Full STL iterator semantics are not required, unlike the standard Boost wrappers
-*/
+        static F fn;
+    };
 
-template<typename T>
-struct range_wrapper {
-    typedef decltype(std::declval<T>().begin()) iterator_t;
+    template <typename F> struct to_str_wrapper
+    {
+        static F fn;
 
-    static std::pair<iterator_t, iterator_t> iter(T &range) {
-        return std::make_pair(range.begin(), range.end());
-    }
+        std::string str(T &x) { return fn(x); }
+    };
 
-    static void wrap(const char *range_name, const char *iter_name) {
-        class_<T>(range_name, no_init)
-                .def("__iter__", iter);
-        iterator_wrapper<iterator_t>().wrap(iter_name);
+    template <typename F1, typename F2>
+    static void wrap(const char *type_name, F1 to_str_fn, F2 from_str_fn)
+    {
+        from_pystring_converter<F2>::fn = from_str_fn;
+        from_pystring_converter<F2>();
+        to_str_wrapper<F1>::fn = to_str_fn;
+        class_<T>(type_name, no_init).def("__str__", to_str_wrapper<F1>::str);
+    };
+};
+
+std::string parse_python_exception();
+
+template <typename Tn> void python_export_global(const char *name, Tn &x)
+{
+    PyObject *m, *d;
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        return;
+    d = PyModule_GetDict(m);
+    try {
+        PyObject *p = incref(object(boost::ref(x)).ptr());
+        PyDict_SetItemString(d, name, p);
+    } catch (boost::python::error_already_set const &) {
+        // Parse and output the exception
+        std::string perror_str = parse_python_exception();
+        std::cout << "Error in Python: " << perror_str << std::endl;
+        std::terminate();
     }
 };
 
-#define WRAP_RANGE(t) range_wrapper<t##Range>().wrap(#t "Range", #t "Iterator")
+void init_python(const char *executable);
+
+void deinit_python();
+
+void execute_python_file(const char *python_file);
 
-void execute_python_file(const char *executable, const char* python_file);
 std::string parse_python_exception();
+
 void arch_appendinittab();
 
 #endif /* end of include guard: COMMON_PYBINDINGS_HH */
diff --git a/common/pycontainers.h b/common/pycontainers.h
new file mode 100644
index 00000000..6e2cdea9
--- /dev/null
+++ b/common/pycontainers.h
@@ -0,0 +1,129 @@
+/*
+ *  nextpnr -- Next Generation Place and Route
+ *
+ *  Copyright (C) 2018  Clifford Wolf <clifford@clifford.at>
+ *  Copyright (C) 2018  David Shah <dave@ds0.me>
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef COMMON_PYCONTAINERS_H
+#define COMMON_PYCONTAINERS_H
+
+#include <utility>
+#include <stdexcept>
+#include <type_traits>
+#include <boost/python.hpp>
+#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
+#include <boost/python/suite/indexing/map_indexing_suite.hpp>
+#include <boost/python/suite/indexing/map_indexing_suite.hpp>
+
+using namespace boost::python;
+
+/*
+A wrapper for a Pythonised nextpnr Iterator. The actual class wrapped is a
+pair<Iterator, Iterator> containing (current, end)
+*/
+
+template<typename T, typename P>
+struct iterator_wrapper {
+	typedef decltype(*(std::declval<T>())) value_t;
+
+	static value_t next(std::pair <T, T> &iter) {
+		if (iter.first != iter.second) {
+			value_t val = *iter.first;
+			++iter.first;
+			return val;
+		} else {
+			PyErr_SetString(PyExc_StopIteration, "End of range reached");
+			boost::python::throw_error_already_set();
+			// Should be unreachable, but prevent control may reach end of non-void
+			throw std::runtime_error("unreachable");
+		}
+	}
+
+	static void wrap(const char *python_name) {
+		class_ < std::pair < T, T >> (python_name, no_init)
+				.def("__next__", next, P());
+	}
+};
+
+/*
+A wrapper for a nextpnr Range. Ranges should have two functions, begin()
+and end() which return iterator-like objects supporting ++, * and !=
+Full STL iterator semantics are not required, unlike the standard Boost wrappers
+*/
+
+template<typename T, typename P = return_value_policy<return_by_value>>
+struct range_wrapper {
+	typedef decltype(std::declval<T>().begin()) iterator_t;
+
+	static std::pair <iterator_t, iterator_t> iter(T &range) {
+		return std::make_pair(range.begin(), range.end());
+	}
+
+	static void wrap(const char *range_name, const char *iter_name) {
+		class_<T>(range_name, no_init)
+				.def("__iter__", iter);
+		iterator_wrapper<iterator_t, P>().wrap(iter_name);
+	}
+	typedef iterator_wrapper<iterator_t, P> iter_wrap;
+};
+
+#define WRAP_RANGE(t) range_wrapper<t##Range>().wrap(#t "Range", #t "Iterator")
+
+/*
+Wrapper for a map, either an unordered_map, regular map or dict
+ */
+inline void KeyError() { PyErr_SetString(PyExc_KeyError, "Key not found"); }
+
+template<typename T>
+struct map_wrapper {
+	typedef typename std::remove_cv<typename std::remove_reference<typename T::key_type>::type>::type K;
+	typedef typename T::mapped_type V;
+	typedef typename T::value_type KV;
+
+	static V &get(T &x, K const &i) {
+		if (x.find(i) != x.end()) return x.at(i);
+		KeyError();
+		std::terminate();
+	}
+
+	static void set(T &x, K const &i, V const &v) {
+		x[i] = v;
+	}
+
+	static void del(T const &x, K const &i) {
+		if (x.find(i) != x.end()) x.erase(i);
+		else KeyError();
+		std::terminate();
+	}
+
+	static void wrap(const char *map_name, const char *kv_name, const char *iter_name) {
+		class_<KV>(kv_name)
+				.def_readonly("first", &KV::first)
+				.def_readwrite("second", &KV::second);
+		typedef range_wrapper<T, return_value_policy<copy_non_const_reference>> rw;
+		typename rw::iter_wrap().wrap(iter_name);
+		class_<T>(map_name, no_init)
+		        .def("__iter__", rw::iter)
+				.def("__len__", &T::size)
+				.def("__getitem__", get, return_internal_reference<>())
+				.def("__setitem__", set, with_custodian_and_ward<1,2>());
+	}
+};
+
+#define WRAP_MAP(t, name) map_wrapper<t>().wrap(#name, #name "KeyValue", #name "Iterator")
+
+#endif
diff --git a/common/rulecheck.cc b/common/rulecheck.cc
index b81695b9..28d4b6b7 100644
--- a/common/rulecheck.cc
+++ b/common/rulecheck.cc
@@ -57,5 +57,6 @@ bool	check_all_nets_driven(Design *design) {
 	}
 
 	if (debug) log_info("  Verified!\n");
+	return true;
 }