Add support for source line tracking through synthesis phase

diff --git a/kernel/rtlil.cc b/kernel/rtlil.cc
index 4427303cc74548066231ffb9b8731b146c88cf51..f132d299b19c61d513d826e66f6672218b88eda7 100644 (file)
--- a/kernel/rtlil.cc
+++ b/kernel/rtlil.cc
@@ -1620,18 +1620,19 @@ RTLIL::Cell *RTLIL::Module::addCell(RTLIL::IdString name, const RTLIL::Cell *oth
 }
 
 #define DEF_METHOD(_func, _y_size, _type) \
-       RTLIL::Cell* RTLIL::Module::add ## _func(RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed) { \
+               RTLIL::Cell* RTLIL::Module::add ## _func(RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed, std::string src) { \
                RTLIL::Cell *cell = addCell(name, _type);           \
                cell->parameters["\\A_SIGNED"] = is_signed;         \
                cell->parameters["\\A_WIDTH"] = sig_a.size();       \
                cell->parameters["\\Y_WIDTH"] = sig_y.size();       \
                cell->setPort("\\A", sig_a);                        \
                cell->setPort("\\Y", sig_y);                        \
+               if (!src.empty()) cell->attributes["\\src"] = src;  \
                return cell;                                        \
        } \
-       RTLIL::SigSpec RTLIL::Module::_func(RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed) { \
+               RTLIL::SigSpec RTLIL::Module::_func(RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed, std::string src) { \
                RTLIL::SigSpec sig_y = addWire(NEW_ID, _y_size);    \
-               add ## _func(name, sig_a, sig_y, is_signed);        \
+               add ## _func(name, sig_a, sig_y, is_signed, src);   \
                return sig_y;                                       \
        }
 DEF_METHOD(Not,        sig_a.size(), "$not")

diff --git a/kernel/rtlil.h b/kernel/rtlil.h
index be558932fb3202ab6b143948bdd3b25cecded5b4..2769d895f65e38ab4507068c1bde3d2fe058f3ab 100644 (file)
--- a/kernel/rtlil.h
+++ b/kernel/rtlil.h
@@ -960,20 +960,20 @@ public:
 
        // The add* methods create a cell and return the created cell. All signals must exist in advance.
 
-       RTLIL::Cell* addNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addPos (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addNeg (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+       RTLIL::Cell* addNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addPos (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addNeg (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
 
        RTLIL::Cell* addAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
 
-       RTLIL::Cell* addReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
-       RTLIL::Cell* addReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+       RTLIL::Cell* addReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
+       RTLIL::Cell* addReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
 
        RTLIL::Cell* addShl    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addShr    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
@@ -998,7 +998,7 @@ public:
        RTLIL::Cell* addMod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addPow (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool a_signed = false, bool b_signed = false);
 
-       RTLIL::Cell* addLogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false);
+       RTLIL::Cell* addLogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed = false, std::string src = "");
        RTLIL::Cell* addLogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
        RTLIL::Cell* addLogicOr  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed = false);
 
@@ -1057,21 +1057,21 @@ public:
 
        // The methods without the add* prefix create a cell and an output signal. They return the newly created output signal.
 
-       RTLIL::SigSpec Not (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec Pos (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+       RTLIL::SigSpec Not (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
+       RTLIL::SigSpec Pos (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
        RTLIL::SigSpec Bu0 (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec Neg (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+       RTLIL::SigSpec Neg (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
 
        RTLIL::SigSpec And  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec Or   (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec Xor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec Xnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
 
-       RTLIL::SigSpec ReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec ReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec ReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec ReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
-       RTLIL::SigSpec ReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+       RTLIL::SigSpec ReduceAnd  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
+       RTLIL::SigSpec ReduceOr   (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
+       RTLIL::SigSpec ReduceXor  (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
+       RTLIL::SigSpec ReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
+       RTLIL::SigSpec ReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
 
        RTLIL::SigSpec Shl    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec Shr    (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
@@ -1096,7 +1096,7 @@ public:
        RTLIL::SigSpec Mod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec Pow (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool a_signed = false, bool b_signed = false);
 
-       RTLIL::SigSpec LogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false);
+       RTLIL::SigSpec LogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed = false, std::string src = "");
        RTLIL::SigSpec LogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
        RTLIL::SigSpec LogicOr  (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed = false);
 

diff --git a/passes/techmap/alumacc.cc b/passes/techmap/alumacc.cc
index 9f6dd02d03f46da54a5c1835ded674e6557f00ed..9593ef27a09d7860845ba65f09557058f93eb2ed 100644 (file)
--- a/passes/techmap/alumacc.cc
+++ b/passes/techmap/alumacc.cc
@@ -55,19 +55,19 @@ struct AlumaccWorker
 
                RTLIL::SigSpec get_gt() {
                        if (GetSize(cached_gt) == 0)
-                               cached_gt = alu_cell->module->Not(NEW_ID, alu_cell->module->Or(NEW_ID, get_lt(), get_eq()));
+                               cached_gt = alu_cell->module->Not(NEW_ID, alu_cell->module->Or(NEW_ID, get_lt(), get_eq()), false, alu_cell->attributes["\\src"].decode_string());
                        return cached_gt;
                }
 
                RTLIL::SigSpec get_eq() {
                        if (GetSize(cached_eq) == 0)
-                               cached_eq = alu_cell->module->ReduceAnd(NEW_ID, alu_cell->getPort("\\X"));
+                               cached_eq = alu_cell->module->ReduceAnd(NEW_ID, alu_cell->getPort("\\X"), false, alu_cell->attributes["\\src"].decode_string());
                        return cached_eq;
                }
 
                RTLIL::SigSpec get_ne() {
                        if (GetSize(cached_ne) == 0)
-                               cached_ne = alu_cell->module->Not(NEW_ID, get_eq());
+                               cached_ne = alu_cell->module->Not(NEW_ID, get_eq(), false, alu_cell->attributes["\\src"].decode_string());
                        return cached_ne;
                }
 
@@ -75,7 +75,7 @@ struct AlumaccWorker
                        if (GetSize(cached_cf) == 0) {
                                cached_cf = alu_cell->getPort("\\CO");
                                log_assert(GetSize(cached_cf) >= 1);
-                               cached_cf = alu_cell->module->Not(NEW_ID, cached_cf[GetSize(cached_cf)-1]);
+                               cached_cf = alu_cell->module->Not(NEW_ID, cached_cf[GetSize(cached_cf)-1], false, alu_cell->attributes["\\src"].decode_string());
                        }
                        return cached_cf;
                }
@@ -352,10 +352,14 @@ struct AlumaccWorker
                {
                        auto n = it.second;
                        auto cell = module->addCell(NEW_ID, "$macc");
+                       auto src = n->cell->attributes["\\src"].decode_string();
+
                        macc_counter++;
 
                        log("  creating $macc cell for %s: %s\n", log_id(n->cell), log_id(cell));
 
+                       if (!src.empty()) cell->attributes["\\src"] = src;
+
                        n->macc.optimize(GetSize(n->y));
                        n->macc.to_cell(cell);
                        cell->setPort("\\Y", n->y);
@@ -452,6 +456,7 @@ struct AlumaccWorker
 
        void replace_alu()
        {
+               std::string src("");
                for (auto &it1 : sig_alu)
                for (auto n : it1.second)
                {
@@ -475,6 +480,9 @@ struct AlumaccWorker
                                log("%s%s", i ? ", ": "", log_id(n->cells[i]));
                        log(": %s\n", log_id(n->alu_cell));
 
+                       src = n->cells.size() > 0 ? n->cells[0]->attributes["\\src"].decode_string() : "";
+                       if (!src.empty()) n->alu_cell->attributes["\\src"] = src;
+
                        n->alu_cell->setPort("\\A", n->a);
                        n->alu_cell->setPort("\\B", n->b);
                        n->alu_cell->setPort("\\CI", GetSize(n->c) ? n->c : RTLIL::S0);

diff --git a/passes/techmap/dfflibmap.cc b/passes/techmap/dfflibmap.cc
index c8104fb7ee67c8c96997815bff67bb2f15288c20..71d708c1829338a62c1d6b7b5fa14ceff84f5a93 100644 (file)
--- a/passes/techmap/dfflibmap.cc
+++ b/passes/techmap/dfflibmap.cc
@@ -478,11 +478,15 @@ static void dfflibmap(RTLIL::Design *design, RTLIL::Module *module, bool prepare
                auto cell_type = cell->type;
                auto cell_name = cell->name;
                auto cell_connections = cell->connections();
+               std::string src = cell->attributes["\\src"].decode_string();
+
                module->remove(cell);
 
                cell_mapping &cm = cell_mappings[cell_type];
                RTLIL::Cell *new_cell = module->addCell(cell_name, prepare_mode ? cm.cell_name : "\\" + cm.cell_name);
 
+               if (!src.empty()) new_cell->attributes["\\src"] = src;
+
                bool has_q = false, has_qn = false;
                for (auto &port : cm.ports) {
                        if (port.second == 'Q') has_q = true;

diff --git a/passes/techmap/techmap.cc b/passes/techmap/techmap.cc
index ae89453d0587508d17a26b29d0f0f323174f4d2c..acc5d747171e40a683074c08024c2108e98d7b83 100644 (file)
--- a/passes/techmap/techmap.cc
+++ b/passes/techmap/techmap.cc
@@ -172,6 +172,7 @@ struct TechmapWorker
 
                std::string orig_cell_name;
                pool<string> extra_src_attrs;
+               std::string src = cell->attributes["\\src"].decode_string();
 
                if (!flatten_mode)
                {
@@ -340,6 +341,8 @@ struct TechmapWorker
                        RTLIL::Cell *c = module->addCell(c_name, it.second);
                        design->select(module, c);
 
+                       if (!src.empty()) c->attributes["\\src"] = src;
+
                        if (!flatten_mode && c->type.substr(0, 2) == "\\$")
                                c->type = c->type.substr(1);
 
@@ -464,7 +467,9 @@ struct TechmapWorker
                        log_assert(cell == module->cell(cell->name));
                        bool mapped_cell = false;
 
+                       std::string src       = cell->attributes["\\src"].decode_string();
                        std::string cell_type = cell->type.str();
+
                        if (in_recursion && cell_type.substr(0, 2) == "\\$")
                                cell_type = cell_type.substr(1);
 
@@ -512,6 +517,8 @@ struct TechmapWorker
                                                                extmapper_module = extmapper_design->addModule(m_name);
                                                                RTLIL::Cell *extmapper_cell = extmapper_module->addCell(cell->type, cell);
 
+                                                               if (!src.empty()) extmapper_cell->attributes["\\src"] = src;
+
                                                                int port_counter = 1;
                                                                for (auto &c : extmapper_cell->connections_) {
                                                                        RTLIL::Wire *w = extmapper_module->addWire(c.first, GetSize(c.second));