systemc: Implement most of sc_inout.

Because sc_inout needs sc_dt::sc_logic and that probably calls
functions from dt_sc_mempool.cc and because those hadn't yet been
stubbed out. This change adds stubs for those as well.

Change-Id: I544a1669575b594d4612558b8b6f47668ac94414
Reviewed-on: https://gem5-review.googlesource.com/12221
Reviewed-by: Gabe Black <gabeblack@google.com>
Maintainer: Gabe Black <gabeblack@google.com>

diff --git a/src/systemc/dt/SConscript b/src/systemc/dt/SConscript
new file mode 100644 (file)
index 0000000..2580875
--- /dev/null
+++ b/src/systemc/dt/SConscript
@@ -0,0 +1,31 @@
+# Copyright 2018 Google, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Gabe Black
+
+Import('*')
+
+if env['USE_SYSTEMC']:
+    Source('sc_mempool.cc')

diff --git a/src/systemc/dt/sc_mempool.cc b/src/systemc/dt/sc_mempool.cc
new file mode 100644 (file)
index 0000000..ae58dd7
--- /dev/null
+++ b/src/systemc/dt/sc_mempool.cc
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018 Google, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Gabe Black
+ */
+
+#include "base/logging.hh"
+#include "systemc/ext/dt/sc_mempool.hh"
+
+namespace sc_core
+{
+
+void *
+sc_mempool::allocate(std::size_t sz)
+{
+    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
+    return nullptr;
+}
+void
+sc_mempool::release(void *p, std::size_t sz)
+{
+    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
+}
+void
+sc_mempool::display_statistics()
+{
+    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
+}
+
+};

diff --git a/src/systemc/ext/channel/sc_inout.hh b/src/systemc/ext/channel/sc_inout.hh
index c183e0fffcdb3acd3adcea379615a8513e8f93bf..54b0ae7da0544cfa779cecbd1e7b7898ead347e9 100644 (file)
--- a/src/systemc/ext/channel/sc_inout.hh
+++ b/src/systemc/ext/channel/sc_inout.hh
@@ -32,7 +32,9 @@
 
 #include <string>
 
+#include "../core/sc_event.hh"
 #include "../core/sc_port.hh"
+#include "../dt/bit/sc_logic.hh"
 #include "sc_signal_inout_if.hh"
 #include "warn_unimpl.hh"
 
@@ -47,130 +49,122 @@ namespace sc_core
 {
 
 class sc_event;
-class sc_event_finder;
 class sc_trace_file;
 
 template <class T>
 class sc_inout : public sc_port<sc_signal_inout_if<T>, 1>
 {
   public:
-    sc_inout() : sc_port<sc_signal_inout_if<T>, 1>() {}
+    sc_inout() : sc_port<sc_signal_inout_if<T>, 1>(), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
+    {}
     explicit sc_inout(const char *name) :
-            sc_port<sc_signal_inout_if<T>, 1>(name)
+        sc_port<sc_signal_inout_if<T>, 1>(name), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
-    virtual ~sc_inout() {}
+    virtual ~sc_inout() { delete initValue; }
 
     // Deprecated binding constructors.
     explicit sc_inout(const sc_signal_inout_if<T> &interface) :
-        sc_port<sc_signal_inout_if<T>, 1>(interface)
+        sc_port<sc_signal_inout_if<T>, 1>(interface), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
     sc_inout(const char *name, const sc_signal_inout_if<T> &interface) :
-        sc_port<sc_signal_inout_if<T>, 1>(name, interface)
+        sc_port<sc_signal_inout_if<T>, 1>(name, interface), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
     explicit sc_inout(sc_port_b<sc_signal_inout_if<T> > &parent) :
-        sc_port<sc_signal_inout_if<T>, 1>(parent)
+        sc_port<sc_signal_inout_if<T>, 1>(parent), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
     sc_inout(const char *name, sc_port_b<sc_signal_inout_if<T> > &parent) :
-        sc_port<sc_signal_inout_if<T>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<T>, 1>(name, parent), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
     explicit sc_inout(sc_port<sc_signal_inout_if<T>, 1> &parent) :
-        sc_port<sc_signal_inout_if<T>, 1>(parent)
+        sc_port<sc_signal_inout_if<T>, 1>(parent), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
     sc_inout(const char *name, sc_port<sc_signal_inout_if<T>, 1> &parent) :
-        sc_port<sc_signal_inout_if<T>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<T>, 1>(name, parent), initValue(nullptr),
+        _valueChangedFinder(*this, &sc_signal_inout_if<T>::value_changed_event)
     {}
 
     void
-    initialize(const T &)
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-    }
-    void
-    initialize(const sc_signal_in_if<T> &)
+    initialize(const T &t)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
+        if (this->size()) {
+            (*this)->write(t);
+        } else {
+            if (!initValue)
+                initValue = new T;
+            *initValue = t;
+        }
     }
+    void initialize(const sc_signal_in_if<T> &i) { initialize(i.read()); }
 
-    virtual void end_of_elaboration() {}
-
-    const T &
-    read() const
+    virtual void
+    end_of_elaboration()
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(const T *)nullptr;
-    }
-    operator const T& () const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(const T *)nullptr;
+        if (initValue) {
+            write(*initValue);
+            delete initValue;
+            initValue = nullptr;
+        }
     }
 
-    void
-    write(const T &)
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-    }
+    const T &read() const { return (*this)->read(); }
+    operator const T& () const { return (*this)->read(); }
+
+    void write(const T &t) { (*this)->write(t); }
     sc_inout<T> &
-    operator = (const T &)
+    operator = (const T &t)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<T> *)nullptr;
+        (*this)->write(t);
+        return *this;
     }
     sc_inout<T> &
-    operator = (const sc_signal_in_if<T> &)
+    operator = (const sc_signal_in_if<T> &i)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<T> *)nullptr;
+        (*this)->write(i.read());
+        return *this;
     }
     sc_inout<T> &
-    operator = (const sc_port<sc_signal_in_if<T>, 1> &)
+    operator = (const sc_port<sc_signal_in_if<T>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<T> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<T> &
-    operator = (const sc_port<sc_signal_inout_if<T>, 1> &)
+    operator = (const sc_port<sc_signal_inout_if<T>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<T> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<T> &
-    operator = (const sc_inout<T> &)
+    operator = (const sc_inout<T> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<T> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
 
-    const sc_event &
-    default_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
+    const sc_event &default_event() const { return (*this)->default_event(); }
     const sc_event &
     value_changed_event() const
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
-    bool
-    event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-    sc_event_finder &
-    value_changed() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
+        return (*this)->value_changed_event();
     }
+    bool event() const { return (*this)->event(); }
+    sc_event_finder &value_changed() const { return _valueChangedFinder; }
 
     virtual const char *kind() const { return "sc_inout"; }
 
   private:
+    T *initValue;
+    mutable sc_event_finder_t<sc_signal_inout_if<T> > _valueChangedFinder;
+
     // Disabled
-    sc_inout(const sc_inout<T> &) : sc_port<sc_signal_inout_if<T>, 1>() {}
+    sc_inout(const sc_inout<T> &);
 };
 
 template <class T>
@@ -184,162 +178,150 @@ template <>
 class sc_inout<bool> : public sc_port<sc_signal_inout_if<bool>, 1>
 {
   public:
-    sc_inout() : sc_port<sc_signal_inout_if<bool>, 1>() {}
+    sc_inout() : sc_port<sc_signal_inout_if<bool>, 1>(), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
+    {}
     explicit sc_inout(const char *name) :
-            sc_port<sc_signal_inout_if<bool>, 1>(name)
+            sc_port<sc_signal_inout_if<bool>, 1>(name), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
-    virtual ~sc_inout() {}
+    virtual ~sc_inout() { delete initValue; }
 
     // Deprecated binding constructors.
     explicit sc_inout(const sc_signal_inout_if<bool> &interface) :
-        sc_port<sc_signal_inout_if<bool>, 1>(interface)
+        sc_port<sc_signal_inout_if<bool>, 1>(interface), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
     sc_inout(const char *name, const sc_signal_inout_if<bool> &interface) :
-        sc_port<sc_signal_inout_if<bool>, 1>(name, interface)
+        sc_port<sc_signal_inout_if<bool>, 1>(name, interface),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
     explicit sc_inout(sc_port_b<sc_signal_inout_if<bool> > &parent) :
-        sc_port<sc_signal_inout_if<bool>, 1>(parent)
+        sc_port<sc_signal_inout_if<bool>, 1>(parent), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
     sc_inout(const char *name, sc_port_b<sc_signal_inout_if<bool> > &parent) :
-        sc_port<sc_signal_inout_if<bool>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<bool>, 1>(name, parent), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
     explicit sc_inout(sc_port<sc_signal_inout_if<bool>, 1> &parent) :
-        sc_port<sc_signal_inout_if<bool>, 1>(parent)
+        sc_port<sc_signal_inout_if<bool>, 1>(parent), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
     sc_inout(const char *name, sc_port<sc_signal_inout_if<bool>, 1> &parent) :
-        sc_port<sc_signal_inout_if<bool>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<bool>, 1>(name, parent), initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<bool>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<bool>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<bool>::negedge_event)
     {}
 
     void
-    initialize(const bool &)
+    initialize(const bool &b)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
+        if (this->size()) {
+            (*this)->write(b);
+        } else {
+            if (!initValue)
+                initValue = new bool;
+            *initValue = b;
+        }
     }
-    void
-    initialize(const sc_signal_in_if<bool> &)
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-    }
-
-    virtual void end_of_elaboration() {}
+    void initialize(const sc_signal_in_if<bool> &i) { initialize(i.read()); }
 
-    const bool &
-    read() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(bool *)nullptr;
-    }
-    operator const bool& () const
+    virtual void
+    end_of_elaboration()
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(bool *)nullptr;
+        if (initValue) {
+            write(*initValue);
+            delete initValue;
+            initValue = nullptr;
+        }
     }
 
-    void
-    write(const bool &)
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-    }
+    const bool &read() const { return (*this)->read(); }
+    operator const bool& () const { return (*this)->read(); }
+
+    void write(const bool &b) { (*this)->write(b); }
     sc_inout<bool> &
-    operator = (const bool &)
+    operator = (const bool &b)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<bool> *)nullptr;
+        (*this)->write(b);
+        return *this;
     }
     sc_inout<bool> &
-    operator = (const sc_signal_in_if<bool> &)
+    operator = (const sc_signal_in_if<bool> &i)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<bool> *)nullptr;
+        (*this)->write(i.read());
+        return *this;
     }
     sc_inout<bool> &
-    operator = (const sc_port<sc_signal_in_if<bool>, 1> &)
+    operator = (const sc_port<sc_signal_in_if<bool>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<bool> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<bool> &
-    operator = (const sc_port<sc_signal_inout_if<bool>, 1> &)
+    operator = (const sc_port<sc_signal_inout_if<bool>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<bool> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<bool> &
-    operator = (const sc_inout<bool> &)
+    operator = (const sc_inout<bool> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<bool> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
 
-    const sc_event &
-    default_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
+    const sc_event &default_event() const { return (*this)->default_event(); }
     const sc_event &
     value_changed_event() const
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
-    const sc_event &
-    posedge_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
-    const sc_event &
-    negedge_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
+        return (*this)->value_changed_event();
     }
+    const sc_event &posedge_event() const { return (*this)->posedge_event(); }
+    const sc_event &negedge_event() const { return (*this)->negedge_event(); }
+    bool event() const { return (*this)->event(); }
+    bool posedge() const { return (*this)->posedge(); }
+    bool negedge() const { return (*this)->negedge(); }
 
-    bool
-    event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-    bool
-    posedge() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-    bool
-    negedge() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-
-    sc_event_finder &
-    value_changed() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
-    sc_event_finder &
-    pos() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
-    sc_event_finder &
-    neg() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
+    sc_event_finder &value_changed() const { return _valueChangedFinder; }
+    sc_event_finder &pos() const { return _posFinder; }
+    sc_event_finder &neg() const { return _negFinder; }
 
     virtual const char *kind() const { return "sc_inout"; }
 
   private:
+    bool *initValue;
+    mutable sc_event_finder_t<sc_signal_inout_if<bool> > _valueChangedFinder;
+    mutable sc_event_finder_t<sc_signal_inout_if<bool> > _posFinder;
+    mutable sc_event_finder_t<sc_signal_inout_if<bool> > _negFinder;
+
     // Disabled
-    sc_inout(const sc_inout<bool> &) :
-            sc_port<sc_signal_inout_if<bool>, 1>() {}
+    sc_inout(const sc_inout<bool> &);
 };
 
 template <>
@@ -354,168 +336,167 @@ class sc_inout<sc_dt::sc_logic> :
         public sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>
 {
   public:
-    sc_inout() : sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>() {}
+    sc_inout() : sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
+    {}
     explicit sc_inout(const char *name) :
-            sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name)
+            sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
-    virtual ~sc_inout() {}
+    virtual ~sc_inout() { delete initValue; }
 
     // Deprecated binding constructors.
     explicit sc_inout(const sc_signal_inout_if<sc_dt::sc_logic> &interface) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(interface)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(interface),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
     sc_inout(const char *name,
             const sc_signal_inout_if<sc_dt::sc_logic> &interface) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, interface)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, interface),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
     explicit sc_inout(
             sc_port_b<sc_signal_inout_if<sc_dt::sc_logic> > &parent) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(parent)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(parent),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
     sc_inout(const char *name,
             sc_port_b<sc_signal_inout_if<sc_dt::sc_logic> > &parent) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, parent),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
     explicit sc_inout(
             sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> &parent) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(parent)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(parent),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
     sc_inout(const char *name,
             sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> &parent) :
-        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, parent)
+        sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>(name, parent),
+        initValue(nullptr),
+        _valueChangedFinder(*this,
+                &sc_signal_inout_if<sc_dt::sc_logic>::value_changed_event),
+        _posFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::posedge_event),
+        _negFinder(*this, &sc_signal_inout_if<sc_dt::sc_logic>::negedge_event)
     {}
 
     void
-    initialize(const sc_dt::sc_logic &)
+    initialize(const sc_dt::sc_logic &l)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
+        if (this->size()) {
+            (*this)->write(l);
+        } else {
+            if (!initValue)
+                initValue = new sc_dt::sc_logic;
+            *initValue = l;
+        }
     }
     void
-    initialize(const sc_signal_in_if<sc_dt::sc_logic> &)
+    initialize(const sc_signal_in_if<sc_dt::sc_logic> &i)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
+        initialize(i.read());
     }
 
-    virtual void end_of_elaboration() {}
-
-    const sc_dt::sc_logic &
-    read() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(const sc_dt::sc_logic *)nullptr;
-    }
-    operator const sc_dt::sc_logic& () const
+    virtual void
+    end_of_elaboration()
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(const sc_dt::sc_logic *)nullptr;
+        if (initValue) {
+            write(*initValue);
+            delete initValue;
+            initValue = nullptr;
+        }
     }
 
-    void
-    write(const sc_dt::sc_logic &)
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-    }
+    const sc_dt::sc_logic &read() const { return (*this)->read(); }
+    operator const sc_dt::sc_logic& () const { return (*this)->read(); }
+
+    void write(const sc_dt::sc_logic &l) { (*this)->write(l); }
     sc_inout<sc_dt::sc_logic> &
-    operator = (const sc_dt::sc_logic &)
+    operator = (const sc_dt::sc_logic &l)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<sc_dt::sc_logic> *)nullptr;
+        (*this)->write(l);
+        return *this;
     }
     sc_inout<sc_dt::sc_logic> &
-    operator = (const sc_signal_in_if<sc_dt::sc_logic> &)
+    operator = (const sc_signal_in_if<sc_dt::sc_logic> &i)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<sc_dt::sc_logic> *)nullptr;
+        (*this)->write(i.read());
+        return *this;
     }
     sc_inout<sc_dt::sc_logic> &
-    operator = (const sc_port<sc_signal_in_if<sc_dt::sc_logic>, 1> &)
+    operator = (const sc_port<sc_signal_in_if<sc_dt::sc_logic>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<sc_dt::sc_logic> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<sc_dt::sc_logic> &
-    operator = (const sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> &)
+    operator = (const sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<sc_dt::sc_logic> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
     sc_inout<sc_dt::sc_logic> &
-    operator = (const sc_inout<sc_dt::sc_logic> &)
+    operator = (const sc_inout<sc_dt::sc_logic> &p)
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_inout<sc_dt::sc_logic> *)nullptr;
+        (*this)->write(p->read());
+        return *this;
     }
 
-    const sc_event &
-    default_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
+    const sc_event &default_event() const { return (*this)->default_event(); }
     const sc_event &
     value_changed_event() const
     {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
-    const sc_event &
-    posedge_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
-    }
-    const sc_event &
-    negedge_event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event *)nullptr;
+        return (*this)->value_changed_event();
     }
+    const sc_event &posedge_event() const { return (*this)->posedge_event(); }
+    const sc_event &negedge_event() const { return (*this)->negedge_event(); }
+    bool event() const { return (*this)->event(); }
+    bool posedge() const { return (*this)->posedge(); }
+    bool negedge() const { return (*this)->negedge(); }
 
-    bool
-    event() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-    bool
-    posedge() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-    bool
-    negedge() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return false;
-    }
-
-    sc_event_finder &
-    value_changed() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
-    sc_event_finder &
-    pos() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
-    sc_event_finder &
-    neg() const
-    {
-        sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
-        return *(sc_event_finder *)nullptr;
-    }
+    sc_event_finder &value_changed() const { return _valueChangedFinder; }
+    sc_event_finder &pos() const { return _posFinder; }
+    sc_event_finder &neg() const { return _negFinder; }
 
     virtual const char *kind() const { return "sc_inout"; }
 
   private:
+    sc_dt::sc_logic *initValue;
+    mutable sc_event_finder_t<
+        sc_signal_inout_if<sc_dt::sc_logic> > _valueChangedFinder;
+    mutable sc_event_finder_t<sc_signal_inout_if<sc_dt::sc_logic> > _posFinder;
+    mutable sc_event_finder_t<sc_signal_inout_if<sc_dt::sc_logic> > _negFinder;
+
     // Disabled
-    sc_inout(const sc_inout<sc_dt::sc_logic> &) :
-            sc_port<sc_signal_inout_if<sc_dt::sc_logic>, 1>()
-    {}
+    sc_inout(const sc_inout<sc_dt::sc_logic> &);
 };
 
 template <>