Systemc: Port over all of the systemc "datatype" headers.

These are the headers originally written by Accellera with a few
modifications. Most significantly, I went through and mostly (but not
entirely) manually editted them to conform to gem5 style and to be
more self consistent. Second, I resolved some macros which optionally
select features. I removed support for deprecated functions, and
otherwise enabled everything.

The actual implementation behind these headers will also be ported
over, but in a subsequent change.

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

4 files changed, 1000 insertions, 0 deletions

diff --git a/src/systemc/ext/dt/misc/_misc.hh b/src/systemc/ext/dt/misc/_misc.hh
new file mode 100644
index 000000000..0f0fdfaef
--- /dev/null
+++ b/src/systemc/ext/dt/misc/_misc.hh
@@ -0,0 +1,36 @@
+/*
+ * 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
+ */
+
+#ifndef __SYSTEMC_EXT_CORE_DT_MISC__MISC_HH__
+#define __SYSTEMC_EXT_CORE_DT_MISC__MISC_HH__
+
+#include "sc_concatref.hh"
+#include "sc_value_base.hh"
+
+#endif  //__SYSTEMC_EXT_CORE_DT_MISC__MISC_HH__
diff --git a/src/systemc/ext/dt/misc/_using.hh b/src/systemc/ext/dt/misc/_using.hh
new file mode 100644
index 000000000..c581ce62c
--- /dev/null
+++ b/src/systemc/ext/dt/misc/_using.hh
@@ -0,0 +1,35 @@
+/*
+ * 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
+ */
+
+#ifndef __SYSTEMC_EXT_CORE_MISC__USING_HH__
+#define __SYSTEMC_EXT_CORE_MISC__USING_HH__
+
+#include "_misc.hh"
+
+#endif  //__SYSTEMC_EXT_CORE_MISC__USING_HH__
diff --git a/src/systemc/ext/dt/misc/sc_concatref.hh b/src/systemc/ext/dt/misc/sc_concatref.hh
new file mode 100644
index 000000000..cd36eb526
--- /dev/null
+++ b/src/systemc/ext/dt/misc/sc_concatref.hh
@@ -0,0 +1,806 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_concatref.h -- Concatenation support.
+
+  Original Author: Andy Goodrich, Forte Design, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+  Andy Goodrich, Forte Design Systems, 17 Nov 2002
+  Creation of sc_concatref class by merging the capabilities of
+  sc_int_concref, sc_int_concref, sc_uint_concref, sc_uint_concref,
+  and implementing the capabilities of sc_signed_concref, sc_signed_concref,
+  sc_unsigned_concref, and sc_unsigned_concref. The resultant class allows
+  mixed mode concatenations on the left and right sides of an assignment.
+
+ *****************************************************************************/
+
+// $Log: sc_concatref.h,v $
+// Revision 1.6  2011/08/24 22:05:48  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2009/11/17 19:58:15  acg
+//  Andy Goodrich: fix of shift rhs possibilities to include "int".
+//
+// Revision 1.4  2009/02/28 00:26:29  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2008/04/29 20:23:55  acg
+//  Andy Goodrich: fixed the code that assigns the value of a string to
+//  an sc_concatref instance.
+//
+// Revision 1.2  2008/02/14 20:57:26  acg
+//  Andy Goodrich: added casts to ~0 instances to keep MSVC compiler happy.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/10/23 19:36:59  acg
+//  Andy Goodrich: changed casts for operations on concatenation values to
+//  mirror those of sc_unsigned. For instance, an sc_unsigned minus a value
+//  returns an sc_signed result, whereas an sc_concatref minus a value was
+//  returning an sc_unsigned result. Now both sc_unsigned and sc_concatref
+//  minus a value return an sc_signed result.
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef __SYSTEMC_EXT_DT_MISC_SC_CONCATREF_HH__
+#define __SYSTEMC_EXT_DT_MISC_SC_CONCATREF_HH__
+
+#include <iostream>
+
+#include "../bit/sc_bv.hh"
+#include "../bit/sc_lv.hh"
+#include "../int/sc_int_base.hh"
+#include "../int/sc_signed.hh"
+#include "../int/sc_uint_base.hh"
+#include "../int/sc_unsigned.hh"
+#include "../sc_temporary.hh"
+#include "sc_value_base.hh"
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_concatref;
+class sc_concat_bool;
+
+} // namespace sc_dt
+
+namespace sc_core
+{
+
+extern sc_byte_heap sc_temp_heap; // Temporary storage.
+
+// explicit template instantiations
+extern template class sc_vpool<sc_dt::sc_concatref>;
+extern template class sc_vpool<sc_dt::sc_concat_bool>;
+
+} // namespace sc_core
+
+namespace sc_dt {
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concatref
+//
+//  Proxy class for sized bit concatenation.
+// ----------------------------------------------------------------------------
+
+class sc_concatref : public sc_generic_base<sc_concatref>, public sc_value_base
+{
+  public:
+    friend class sc_core::sc_vpool<sc_concatref>;
+
+    inline void
+    initialize(sc_value_base &left, sc_value_base &right)
+    {
+        bool left_xz; // True if x's and/or z's found in left.
+        bool right_xz; // True if x's and/or z's found in right.
+
+        m_left_p = (sc_value_base *)&left;
+        m_right_p = (sc_value_base *)&right;
+        m_len_r = right.concat_length(&right_xz);
+        m_len = left.concat_length(&left_xz) + m_len_r;
+        m_flags = (left_xz || right_xz) ? cf_xz_present : cf_none;
+    }
+
+
+    inline void
+    initialize(const sc_value_base &left, const sc_value_base &right)
+    {
+        bool left_xz;   // True if x's and/or z's found in left.
+        bool right_xz;  // True if x's and/or z's found in right.
+
+        m_left_p = (sc_value_base *)&left;
+        m_right_p = (sc_value_base *)&right;
+        m_len_r = right.concat_length(&right_xz);
+        m_len = left.concat_length(&left_xz) + m_len_r;
+        m_flags = (left_xz || right_xz) ? cf_xz_present : cf_none;
+    }
+
+    // destructor
+    virtual ~sc_concatref() {}
+
+    // capacity
+    unsigned int length() const { return m_len; }
+
+    // concatenation
+    virtual int
+    concat_length(bool *xz_present_p) const
+    {
+        if (xz_present_p)
+            *xz_present_p = m_flags & cf_xz_present ? true : false;
+        return m_len;
+    }
+
+    virtual void
+    concat_clear_data(bool to_ones)
+    {
+        m_left_p->concat_clear_data(to_ones);
+        m_right_p->concat_clear_data(to_ones);
+    }
+
+    virtual bool
+    concat_get_ctrl(sc_digit *dst_p, int low_i) const
+    {
+        bool rnz = m_right_p->concat_get_ctrl(dst_p, low_i);
+        bool lnz = m_left_p->concat_get_ctrl(dst_p, low_i + m_len_r);
+        return rnz || lnz;
+    }
+
+    virtual bool
+    concat_get_data(sc_digit *dst_p, int low_i) const
+    {
+        bool rnz = m_right_p->concat_get_data(dst_p, low_i);
+        bool lnz = m_left_p->concat_get_data(dst_p, low_i + m_len_r);
+        return rnz || lnz;
+    }
+
+    virtual uint64
+    concat_get_uint64() const
+    {
+        if (m_len_r >= 64) {
+            return m_right_p->concat_get_uint64();
+        } else {
+            return (m_left_p->concat_get_uint64() << m_len_r) |
+                m_right_p->concat_get_uint64();
+        }
+    }
+
+    virtual void
+    concat_set(int64 src, int low_i)
+    {
+        m_right_p->concat_set(src, low_i);
+        m_left_p->concat_set(src, low_i + m_len_r);
+    }
+
+    virtual void
+    concat_set(const sc_signed &src, int low_i)
+    {
+        m_right_p->concat_set(src, low_i);
+        m_left_p->concat_set(src, low_i + m_len_r);
+    }
+
+    virtual void
+    concat_set(const sc_unsigned &src, int low_i)
+    {
+        m_right_p->concat_set(src, low_i);
+        m_left_p->concat_set(src, low_i + m_len_r);
+    }
+
+    virtual void
+    concat_set(uint64 src, int low_i)
+    {
+        m_right_p->concat_set(src, low_i);
+        m_left_p->concat_set(src, low_i + m_len_r);
+    }
+
+    // explicit conversions
+    uint64
+    to_uint64() const
+    {
+        uint64 mask;
+        uint64 result;
+
+        result = m_right_p->concat_get_uint64();
+        if (m_len_r < 64) {
+            mask = (uint64)~0;
+            result = (m_left_p->concat_get_uint64() << m_len_r) |
+                        (result & ~(mask << m_len_r));
+        }
+        if (m_len < 64) {
+            mask = (uint64)~0;
+            result = result & ~(mask << m_len);
+        }
+        return result;
+    }
+
+    const sc_unsigned &
+    value() const
+    {
+        bool left_non_zero;
+        sc_unsigned *result_p = sc_unsigned::m_pool.allocate();
+        bool right_non_zero;
+
+        result_p->nbits = result_p->num_bits(m_len);
+        result_p->ndigits = DIV_CEIL(result_p->nbits);
+        result_p->digit = (sc_digit *)sc_core::sc_temp_heap.allocate(
+            sizeof(sc_digit) * result_p->ndigits);
+        result_p->digit[result_p->ndigits - 1] = 0;
+        right_non_zero = m_right_p->concat_get_data(result_p->digit, 0);
+        left_non_zero = m_left_p->concat_get_data(result_p->digit, m_len_r);
+        if (left_non_zero || right_non_zero)
+            result_p->sgn = SC_POS;
+        else
+            result_p->sgn = SC_ZERO;
+        return *result_p;
+    }
+
+    int64 to_int64() const { return (int64)to_uint64(); }
+    int to_int() const { return (int)to_int64(); }
+    unsigned int to_uint() const { return (unsigned int)to_uint64(); }
+    long to_long() const { return (long)to_int64(); }
+    unsigned long to_ulong() const { return (unsigned long)to_uint64(); }
+    double to_double() const { return value().to_double(); }
+
+    void to_sc_signed(sc_signed &target) const { target = value(); }
+
+    void to_sc_unsigned(sc_unsigned &target) const { target = value(); }
+
+    // implicit conversions:
+    operator uint64 () const { return to_uint64(); }
+
+    operator const sc_unsigned & () const { return value(); }
+
+    // unary operators:
+    sc_unsigned operator + () const { return value(); }
+
+    sc_signed operator - () const { return -value(); }
+
+    sc_unsigned operator ~ () const { return ~value(); }
+
+    // explicit conversion to character string
+    const std::string
+    to_string(sc_numrep numrep=SC_DEC) const
+    {
+        return value().to_string(numrep);
+    }
+
+    const std::string
+    to_string(sc_numrep numrep, bool w_prefix) const
+    {
+        return value().to_string(numrep,w_prefix);
+    }
+
+    // assignments
+    inline const sc_concatref &
+    operator = (int v)
+    {
+        m_right_p->concat_set((int64)v, 0);
+        m_left_p->concat_set((int64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref &
+    operator = (long v)
+    {
+        m_right_p->concat_set((int64)v, 0);
+        m_left_p->concat_set((int64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref &
+    operator = (int64 v)
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref &
+    operator = (unsigned int v)
+    {
+        m_right_p->concat_set((uint64)v, 0);
+        m_left_p->concat_set((uint64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref &
+    operator = (unsigned long v)
+    {
+        m_right_p->concat_set((uint64)v, 0);
+        m_left_p->concat_set((uint64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref &
+    operator = (uint64 v)
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const sc_concatref &v)
+    {
+        sc_unsigned temp(v.length());
+        temp = v.value();
+        m_right_p->concat_set(temp, 0);
+        m_left_p->concat_set(temp, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const sc_signed &v)
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const sc_unsigned &v)
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const char *v_p)
+    {
+        sc_unsigned v(m_len);
+        v = v_p;
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const sc_bv_base &v)
+    {
+        sc_unsigned temp(v.length());
+        temp = v;
+        m_right_p->concat_set(temp, 0);
+        m_left_p->concat_set(temp, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref &
+    operator = (const sc_lv_base &v)
+    {
+        sc_unsigned data(v.length());
+        data = v;
+        m_right_p->concat_set(data, 0);
+        m_left_p->concat_set(data, m_len_r);
+        return *this;
+    }
+
+    // reduce methods
+    bool and_reduce() const { return value().and_reduce(); }
+    bool nand_reduce() const { return value().nand_reduce(); }
+    bool or_reduce() const { return value().or_reduce(); }
+    bool nor_reduce() const { return value().nor_reduce(); }
+    bool xor_reduce() const { return value().xor_reduce(); }
+    bool xnor_reduce() const { return value().xnor_reduce(); }
+
+    // other methods
+    void print(::std::ostream &os=::std::cout) const { os << this->value(); }
+
+    void
+    scan(::std::istream &is)
+    {
+        std::string s;
+        is >> s;
+        *this = s.c_str();
+    }
+
+  public:
+    // Pool of temporary objects.
+    static sc_core::sc_vpool<sc_concatref> m_pool;
+
+  public:
+    enum concat_flags {
+        cf_none = 0,        // Normal value.
+        cf_xz_present = 1   // X and/or Z values present.
+    };
+
+  protected:
+    sc_value_base *m_left_p;  // Left hand operand of concatenation.
+    sc_value_base *m_right_p; // Right hand operand of concatenation.
+    int m_len;                // Length of concatenation.
+    int m_len_r;              // Length of m_rightt_p.
+    concat_flags m_flags;     // Value is read only.
+
+  private:
+    sc_concatref(const sc_concatref &);
+    sc_concatref() : m_left_p(0), m_right_p(0), m_len(0), m_len_r(0), m_flags()
+    {}
+};
+
+// functional notation for the reduce methods
+inline bool and_reduce(const sc_concatref &a) { return a.and_reduce(); }
+inline bool nand_reduce(const sc_concatref &a) { return a.nand_reduce(); }
+inline bool or_reduce(const sc_concatref &a) { return a.or_reduce(); }
+inline bool nor_reduce(const sc_concatref &a) { return a.nor_reduce(); }
+inline bool xor_reduce(const sc_concatref &a) { return a.xor_reduce(); }
+inline bool xnor_reduce(const sc_concatref &a) { return a.xnor_reduce(); }
+
+// SHIFT OPERATORS FOR sc_concatref OBJECT INSTANCES:
+//
+// Because sc_concatref has implicit casts to both uint64 and sc_unsigned
+// it is necessary to disambiguate the use of the shift operators. We do
+// this in favor of sc_unsigned so that precision is not lost. To get an
+// integer-based result use a cast to uint64 before performing the shift.
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, uint64 shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, int64 shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, unsigned long shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, int shift)
+{
+    return target.value() << shift;
+}
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, unsigned int shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned
+operator << (const sc_concatref &target, long shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, uint64 shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, int64 shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, unsigned long shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, int shift)
+{
+    return target.value() >> shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, unsigned int shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned
+operator >> (const sc_concatref &target, long shift)
+{
+    return target.value() >> (int)shift;
+}
+
+// STREAM OPERATORS FOR sc_concatref OBJECT INSTANCES:
+inline ::std::ostream &
+operator << (::std::ostream &os, const sc_concatref &v)
+{
+    return os << v.value();
+}
+
+inline ::std::istream &
+operator >> (::std::istream &is, sc_concatref &a)
+{
+    sc_unsigned temp(a.concat_length(0));
+    temp.scan(is);
+    a = temp;
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concat_bool
+//
+//  Proxy class for read-only boolean values in concatenations.
+// ----------------------------------------------------------------------------
+
+class sc_concat_bool : public sc_value_base
+{
+  protected:
+    static sc_core::sc_vpool<sc_concat_bool> m_pool; // Temporaries pool.
+    bool m_value;                                    // Value for this obj.
+
+  public:
+    // constructor:
+    sc_concat_bool() : sc_value_base(), m_value() {}
+
+    // destructor:
+    virtual ~sc_concat_bool() { }
+
+    // allocation of temporary object:
+    static inline sc_concat_bool *
+    allocate(bool v)
+    {
+        sc_concat_bool *result_p = m_pool.allocate();
+        result_p->m_value = v;
+        return result_p;
+    }
+
+    // concatenation:
+    virtual int
+    concat_length(bool *xz_present_p) const
+    {
+        if (xz_present_p)
+            *xz_present_p = false;
+        return 1;
+    }
+
+    virtual bool
+    concat_get_ctrl(sc_digit *dst_p, int low_i) const
+    {
+        int bit = 1 << (low_i % BITS_PER_DIGIT);
+        int word_i = low_i / BITS_PER_DIGIT;
+        dst_p[word_i] &= ~bit;
+        return false;
+    }
+
+    virtual bool
+    concat_get_data(sc_digit *dst_p, int low_i) const
+    {
+        int bit = 1 << (low_i % BITS_PER_DIGIT);
+        int word_i = low_i / BITS_PER_DIGIT;
+        if (m_value)
+            dst_p[word_i] |= bit;
+        else
+            dst_p[word_i] &= ~bit;
+        return m_value;
+    }
+
+    virtual uint64
+    concat_get_uint64() const
+    {
+        return m_value ? 1 : 0;
+    }
+};
+
+
+// ----------------------------------------------------------------------------
+// ARITHMETIC AND LOGIC OPERATORS FOR sc_concatref
+// ----------------------------------------------------------------------------
+
+#define SC_CONCAT_OP_TYPE(RESULT, OP, OTHER_TYPE) \
+    inline RESULT \
+    operator OP (const sc_concatref &a, OTHER_TYPE b) \
+    { \
+        return a.value() OP b; \
+    } \
+    inline RESULT \
+    operator OP (OTHER_TYPE a, const sc_concatref &b) \
+    { \
+        return a OP b.value(); \
+    }
+
+
+#define SC_CONCAT_OP(RESULT, OP) \
+    inline RESULT \
+    operator OP (const sc_concatref &a, const sc_concatref &b) \
+    { \
+        return a.value() OP b.value(); \
+    }  \
+    SC_CONCAT_OP_TYPE(const sc_signed, OP, int) \
+    SC_CONCAT_OP_TYPE(const sc_signed, OP, long) \
+    SC_CONCAT_OP_TYPE(const sc_signed, OP, int64) \
+    SC_CONCAT_OP_TYPE(RESULT, OP, unsigned int) \
+    SC_CONCAT_OP_TYPE(RESULT, OP, unsigned long) \
+    SC_CONCAT_OP_TYPE(RESULT, OP, uint64) \
+    SC_CONCAT_OP_TYPE(const sc_signed, OP, const sc_int_base &) \
+    SC_CONCAT_OP_TYPE(RESULT, OP, const sc_uint_base &) \
+    SC_CONCAT_OP_TYPE(const sc_signed, OP, const sc_signed &) \
+    SC_CONCAT_OP_TYPE(RESULT, OP, const sc_unsigned &) \
+    inline RESULT \
+    operator OP (const sc_concatref &a, bool b) \
+    { \
+        return a.value() OP (int)b; \
+    } \
+    inline RESULT \
+    operator OP (bool a, const sc_concatref &b) \
+    { \
+        return (int)a OP b.value(); \
+    }
+
+#define SC_CONCAT_BOOL_OP(OP) \
+    inline bool \
+    operator OP (const sc_concatref &a, const sc_concatref &b) \
+    { \
+        return a.value() OP b.value(); \
+    }  \
+    SC_CONCAT_OP_TYPE(bool, OP, int) \
+    SC_CONCAT_OP_TYPE(bool, OP, long) \
+    SC_CONCAT_OP_TYPE(bool, OP, int64) \
+    SC_CONCAT_OP_TYPE(bool, OP, unsigned int) \
+    SC_CONCAT_OP_TYPE(bool, OP, unsigned long) \
+    SC_CONCAT_OP_TYPE(bool, OP, uint64) \
+    SC_CONCAT_OP_TYPE(bool, OP, const sc_int_base &) \
+    SC_CONCAT_OP_TYPE(bool, OP, const sc_uint_base &) \
+    SC_CONCAT_OP_TYPE(bool, OP, const sc_signed &) \
+    SC_CONCAT_OP_TYPE(bool, OP, const sc_unsigned &) \
+    inline bool \
+    operator OP (const sc_concatref &a, bool b) \
+    { \
+        return a.value() OP (int)b; \
+    } \
+    inline bool \
+    operator OP (bool a, const sc_concatref &b) \
+    { \
+        return (int)a OP b.value(); \
+    }
+
+SC_CONCAT_OP(const sc_unsigned, +)
+SC_CONCAT_OP(const sc_signed, -)
+SC_CONCAT_OP(const sc_unsigned, *)
+SC_CONCAT_OP(const sc_unsigned, /)
+SC_CONCAT_OP(const sc_unsigned, %)
+SC_CONCAT_OP(const sc_unsigned, &)
+SC_CONCAT_OP(const sc_unsigned, |)
+SC_CONCAT_OP(const sc_unsigned, ^)
+SC_CONCAT_BOOL_OP(==)
+SC_CONCAT_BOOL_OP(<=)
+SC_CONCAT_BOOL_OP(>=)
+SC_CONCAT_BOOL_OP(!=)
+SC_CONCAT_BOOL_OP(>)
+SC_CONCAT_BOOL_OP(<)
+
+#undef SC_CONCAT_OP
+#undef SC_CONCAT_OP_TYPE
+
+
+// ----------------------------------------------------------------------------
+// CONCATENATION FUNCTION AND OPERATOR FOR STANDARD SYSTEM C DATA TYPES:
+// ----------------------------------------------------------------------------
+
+inline sc_dt::sc_concatref &
+concat(sc_dt::sc_value_base &a, sc_dt::sc_value_base &b)
+{
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, b);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+concat(const sc_dt::sc_value_base &a, const sc_dt::sc_value_base &b)
+{
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, b);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+concat(const sc_dt::sc_value_base &a, bool b)
+{
+    const sc_dt::sc_concat_bool *b_p; // Proxy for boolean value.
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    b_p = sc_dt::sc_concat_bool::allocate(b);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, *b_p);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+concat(bool a, const sc_dt::sc_value_base &b)
+{
+    const sc_dt::sc_concat_bool *a_p; // Proxy for boolean value.
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    a_p = sc_dt::sc_concat_bool::allocate(a);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(*a_p, b);
+    return *result_p;
+}
+
+inline sc_dt::sc_concatref &
+operator , (sc_dt::sc_value_base &a, sc_dt::sc_value_base &b)
+{
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, b);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+operator , (const sc_dt::sc_value_base &a, const sc_dt::sc_value_base &b)
+{
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, b);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+operator , (const sc_dt::sc_value_base &a, bool b)
+{
+    const sc_dt::sc_concat_bool *b_p; // Proxy for boolean value.
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    b_p = sc_dt::sc_concat_bool::allocate(b);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(a, *b_p);
+    return *result_p;
+}
+
+inline const sc_dt::sc_concatref &
+operator , (bool a, const sc_dt::sc_value_base &b)
+{
+    const sc_dt::sc_concat_bool *a_p; // Proxy for boolean value.
+    sc_dt::sc_concatref *result_p; // Proxy for the concatenation.
+
+    a_p = sc_dt::sc_concat_bool::allocate(a);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize(*a_p, b);
+    return *result_p;
+}
+
+} // namespace sc_dt
+
+#endif //  __SYSTEMC_EXT_DT_MISC_SC_CONCATREF_HH__
diff --git a/src/systemc/ext/dt/misc/sc_value_base.hh b/src/systemc/ext/dt/misc/sc_value_base.hh
new file mode 100644
index 000000000..2ea6ce22e
--- /dev/null
+++ b/src/systemc/ext/dt/misc/sc_value_base.hh
@@ -0,0 +1,123 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_value_base.h -- Base class for SystemC bit values.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_value_base.h,v $
+// Revision 1.4  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.3  2011/08/24 22:05:48  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/06/28 21:23:04  acg
+//  Andy Goodrich: merging of SCV tree.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef __SYSTEMC_EXT_DT_MISC_SC_VALUE_BASE_HH__
+#define __SYSTEMC_EXT_DT_MISC_SC_VALUE_BASE_HH__
+
+#include "../int/sc_nbdefs.hh"
+
+namespace sc_dt
+{
+
+class sc_signed;
+class sc_unsigned;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_value_base
+//
+//  Abstract base class of all SystemC native variables. It provides
+//  support for concatenation operations via a set of virtual methods.
+//  A general description of the methods appear with their default
+//  definitions in sc_object.cpp.
+// ----------------------------------------------------------------------------
+
+class sc_value_base
+{
+    friend class sc_concatref;
+  private:
+    virtual void concat_clear_data(bool to_ones=false);
+    virtual bool concat_get_ctrl(sc_digit *dst_p, int low_i) const;
+    virtual bool concat_get_data(sc_digit *dst_p, int low_i) const;
+    virtual uint64 concat_get_uint64() const;
+    virtual int concat_length(bool *xz_present_p=0) const;
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+  public:
+    virtual ~sc_value_base() {}
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_generic_base
+//
+//  Proxy class for user-defined value classes and other classes that
+//  are defined outside of SystemC.
+//  The class is utilized as a base class for the arbitrary class:
+//
+//       class my_class : public sc_generic_base<my_class>
+//
+//  The purpose of the class is to allow to_XXXX methods defined within that
+//  class so that assignments and casts from the arbitrary class to native
+//  SystemC types are possible. To interact correctly with the SystemC library
+//  the class derived from sc_generic_base must implement the following
+//  methods:
+//    (1) uint64 to_uint64() const
+//    (2) int64  to_int64() const
+//    (3) void to_sc_unsigned( sc_unsigned& ) const
+//    (4) void to_sc_signed( sc_signed& ) const
+// ----------------------------------------------------------------------------
+template< class T >
+class sc_generic_base
+{
+  public:
+    inline const T *operator-> () const { return (const T *)this; }
+    inline T *operator-> () { return (T *)this; }
+};
+
+} // namespace sc_dt
+
+#endif // SYSTEMC_EXT_DT_MISC_SC_VALUE_BASE_HH__