kernel/mem: Recognize some deprecated memory port configs.

[yosys.git] / kernel / sigtools.h

diff --git a/kernel/sigtools.h b/kernel/sigtools.h
index 094d73941507db25602fbb7cd4d47765ab96e6a1..c631fa481dad7363f0b75d3b0cb62707880364db 100644 (file)
--- a/kernel/sigtools.h
+++ b/kernel/sigtools.h
@@ -39,7 +39,7 @@ struct SigPool
                bits.clear();
        }
 
-       void add(RTLIL::SigSpec sig)
+       void add(const RTLIL::SigSpec &sig)
        {
                for (auto &bit : sig)
                        if (bit.wire != NULL)
@@ -52,7 +52,7 @@ struct SigPool
                        bits.insert(bit);
        }
 
-       void del(RTLIL::SigSpec sig)
+       void del(const RTLIL::SigSpec &sig)
        {
                for (auto &bit : sig)
                        if (bit.wire != NULL)
@@ -65,7 +65,7 @@ struct SigPool
                        bits.erase(bit);
        }
 
-       void expand(RTLIL::SigSpec from, RTLIL::SigSpec to)
+       void expand(const RTLIL::SigSpec &from, const RTLIL::SigSpec &to)
        {
                log_assert(GetSize(from) == GetSize(to));
                for (int i = 0; i < GetSize(from); i++) {
@@ -75,16 +75,16 @@ struct SigPool
                }
        }
 
-       RTLIL::SigSpec extract(RTLIL::SigSpec sig)
+       RTLIL::SigSpec extract(const RTLIL::SigSpec &sig) const
        {
                RTLIL::SigSpec result;
                for (auto &bit : sig)
                        if (bit.wire != NULL && bits.count(bit))
-                               result.append_bit(bit);
+                               result.append(bit);
                return result;
        }
 
-       RTLIL::SigSpec remove(RTLIL::SigSpec sig)
+       RTLIL::SigSpec remove(const RTLIL::SigSpec &sig) const
        {
                RTLIL::SigSpec result;
                for (auto &bit : sig)
@@ -93,12 +93,12 @@ struct SigPool
                return result;
        }
 
-       bool check(RTLIL::SigBit bit)
+       bool check(const RTLIL::SigBit &bit) const
        {
                return bit.wire != NULL && bits.count(bit);
        }
 
-       bool check_any(RTLIL::SigSpec sig)
+       bool check_any(const RTLIL::SigSpec &sig) const
        {
                for (auto &bit : sig)
                        if (bit.wire != NULL && bits.count(bit))
@@ -106,7 +106,7 @@ struct SigPool
                return false;
        }
 
-       bool check_all(RTLIL::SigSpec sig)
+       bool check_all(const RTLIL::SigSpec &sig) const
        {
                for (auto &bit : sig)
                        if (bit.wire != NULL && bits.count(bit) == 0)
@@ -114,14 +114,14 @@ struct SigPool
                return true;
        }
 
-       RTLIL::SigSpec export_one()
+       RTLIL::SigSpec export_one() const
        {
                for (auto &bit : bits)
                        return RTLIL::SigSpec(bit.first, bit.second);
                return RTLIL::SigSpec();
        }
 
-       RTLIL::SigSpec export_all()
+       RTLIL::SigSpec export_all() const
        {
                pool<RTLIL::SigBit> sig;
                for (auto &bit : bits)
@@ -135,10 +135,10 @@ struct SigPool
        }
 };
 
-template <typename T, class Compare = std::less<T>>
+template <typename T, class Compare = void>
 struct SigSet
 {
-       static_assert(!std::is_pointer<T>::value || !std::is_same<Compare, std::less<T>>::value, "Explicit `Compare' class require for SigSet with pointer-type values!");
+       static_assert(!std::is_same<Compare,void>::value, "Default value for `Compare' class not found for SigSet<T>. Please specify.");
 
        struct bitDef_t : public std::pair<RTLIL::Wire*, int> {
                bitDef_t() : std::pair<RTLIL::Wire*, int>(NULL, 0) { }
@@ -153,67 +153,67 @@ struct SigSet
                bits.clear();
        }
 
-       void insert(RTLIL::SigSpec sig, T data)
+       void insert(const RTLIL::SigSpec &sig, T data)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL)
                                bits[bit].insert(data);
        }
 
-       void insert(RTLIL::SigSpec sig, const std::set<T> &data)
+       void insert(const RTLIL::SigSpec& sig, const std::set<T> &data)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL)
                                bits[bit].insert(data.begin(), data.end());
        }
 
-       void erase(RTLIL::SigSpec sig)
+       void erase(const RTLIL::SigSpec& sig)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL)
                                bits[bit].clear();
        }
 
-       void erase(RTLIL::SigSpec sig, T data)
+       void erase(const RTLIL::SigSpec &sig, T data)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL)
                                bits[bit].erase(data);
        }
 
-       void erase(RTLIL::SigSpec sig, const std::set<T> &data)
+       void erase(const RTLIL::SigSpec &sig, const std::set<T> &data)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL)
                                bits[bit].erase(data.begin(), data.end());
        }
 
-       void find(RTLIL::SigSpec sig, std::set<T> &result)
+       void find(const RTLIL::SigSpec &sig, std::set<T> &result)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL) {
                                auto &data = bits[bit];
                                result.insert(data.begin(), data.end());
                        }
        }
 
-       void find(RTLIL::SigSpec sig, pool<T> &result)
+       void find(const RTLIL::SigSpec &sig, pool<T> &result)
        {
-               for (auto &bit : sig)
+               for (const auto &bit : sig)
                        if (bit.wire != NULL) {
                                auto &data = bits[bit];
                                result.insert(data.begin(), data.end());
                        }
        }
 
-       std::set<T> find(RTLIL::SigSpec sig)
+       std::set<T> find(const RTLIL::SigSpec &sig)
        {
                std::set<T> result;
                find(sig, result);
                return result;
        }
 
-       bool has(RTLIL::SigSpec sig)
+       bool has(const RTLIL::SigSpec &sig)
        {
                for (auto &bit : sig)
                        if (bit.wire != NULL && bits.count(bit))
@@ -222,6 +222,13 @@ struct SigSet
        }
 };
 
+template<typename T>
+class SigSet<T, typename std::enable_if<!std::is_pointer<T>::value>::type> : public SigSet<T, std::less<T>> {};
+template<typename T>
+using sort_by_name_id_guard = typename std::enable_if<std::is_same<T,RTLIL::Cell*>::value>::type;
+template<typename T>
+class SigSet<T, sort_by_name_id_guard<T>> : public SigSet<T, RTLIL::sort_by_name_id<typename std::remove_pointer<T>::type>> {};
+
 struct SigMap
 {
        mfp<SigBit> database;
@@ -255,7 +262,7 @@ struct SigMap
                        add(it.first, it.second);
        }
 
-       void add(RTLIL::SigSpec from, RTLIL::SigSpec to)
+       void add(const RTLIL::SigSpec& from, const RTLIL::SigSpec& to)
        {
                log_assert(GetSize(from) == GetSize(to));
 
@@ -280,15 +287,21 @@ struct SigMap
                }
        }
 
-       void add(RTLIL::SigSpec sig)
+       void add(const RTLIL::SigBit &bit)
        {
-               for (auto &bit : sig) {
-                       RTLIL::SigBit b = database.find(bit);
-                       if (b.wire != nullptr)
-                               database.promote(bit);
-               }
+               const auto &b = database.find(bit);
+               if (b.wire != nullptr)
+                       database.promote(bit);
        }
 
+       void add(const RTLIL::SigSpec &sig)
+       {
+               for (const auto &bit : sig)
+                       add(bit);
+       }
+
+       inline void add(Wire *wire) { return add(RTLIL::SigSpec(wire)); }
+
        void apply(RTLIL::SigBit &bit) const
        {
                bit = database.find(bit);
@@ -322,7 +335,7 @@ struct SigMap
        RTLIL::SigSpec allbits() const
        {
                RTLIL::SigSpec sig;
-               for (auto &bit : database)
+               for (const auto &bit : database)
                        if (bit.wire != nullptr)
                                sig.append(bit);
                return sig;