systemc: Add the Accellera implementation for the data type classes.

These files have been cleaned up style wise, and some macros have been
resolved like they were for the header files.

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

1 files changed, 810 insertions, 0 deletions

diff --git a/src/systemc/dt/fx/sc_fxval.cc b/src/systemc/dt/fx/sc_fxval.cc
new file mode 100644
index 000000000..45d7d5735
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxval.cc
@@ -0,0 +1,810 @@
+/*****************************************************************************
+
+  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_fxval.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxval.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cctype>
+#include <cfloat>
+#include <cmath>
+#include <cstdlib>
+
+#include "systemc/ext/dt/fx/sc_fxval.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// explicit conversion to character string
+
+const std::string
+sc_fxval::to_string() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep) const
+{
+    return std::string(m_rep->to_string(numrep, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0), SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, fmt));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, -1, fmt));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0), fmt));
+}
+
+
+const std::string
+sc_fxval::to_dec() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_bin() const
+{
+    return std::string(m_rep->to_string(SC_BIN, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_oct() const
+{
+    return std::string(m_rep->to_string(SC_OCT, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_hex() const
+{
+    return std::string(m_rep->to_string(SC_HEX, -1, SC_E));
+}
+
+
+// print or dump content
+
+void sc_fxval::print(::std::ostream &os) const { m_rep->print(os); }
+
+void
+sc_fxval::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval::dump(::std::ostream &os) const
+{
+    os << "sc_fxval" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "rep = ";
+    m_rep->dump(os);
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+// protected methods and friend functions
+sc_fxval_observer *
+sc_fxval::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxval_observer *tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval::unlock_observer(sc_fxval_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value types; limited precision.
+// ----------------------------------------------------------------------------
+
+static void
+print_dec(scfx_string &s, scfx_ieee_double id, int w_prefix, sc_fmt fmt)
+{
+    if (id.negative() != 0) {
+        id.negative(0);
+        s += '-';
+    }
+
+    if (w_prefix == 1) {
+        scfx_print_prefix(s, SC_DEC);
+    }
+
+    if (id.is_zero()) {
+        s += '0';
+        return;
+    }
+
+    // split 'id' into its integer and fractional part
+    double int_part;
+    double frac_part = std::modf(static_cast<double>(id), &int_part);
+
+    int i;
+
+    // print integer part
+    int int_digits = 0;
+    int int_zeros  = 0;
+
+    if (int_part != 0.0) {
+        int_digits = (int)std::ceil(std::log10(int_part + 1.0));
+
+        int len = s.length();
+        s.append(int_digits);
+
+        bool zero_digits = (frac_part == 0.0 && fmt != SC_F);
+
+        for (i = int_digits + len - 1; i >= len; i--) {
+            unsigned int remainder = (unsigned int)std::fmod(int_part, 10.0);
+            s[i] = static_cast<char>('0' + remainder);
+
+            if (zero_digits) {
+                if (remainder == 0)
+                    int_zeros++;
+                else
+                    zero_digits = false;
+            }
+
+            int_part /= 10.0;
+        }
+
+        // discard trailing zeros from int_part
+        s.discard(int_zeros);
+
+        if (s[len] == '0') {
+            // int_digits was overestimated by one
+            s.remove(len);
+            --int_digits;
+        }
+    }
+
+    // print fractional part
+    int frac_digits = 0;
+    int frac_zeros  = 0;
+
+    if (frac_part != 0.0) {
+        s += '.';
+
+        bool zero_digits = (int_digits == 0 && fmt != SC_F);
+
+        frac_zeros = (int)std::floor(-std::log10(frac_part + DBL_EPSILON));
+
+        frac_part *= std::pow(10.0, frac_zeros);
+
+        frac_digits = frac_zeros;
+        if (!zero_digits) {
+            for (i = 0; i < frac_zeros; i++)
+                s += '0';
+            frac_zeros = 0;
+        }
+
+        while (frac_part != 0.0) {
+            frac_part *= 10.0;
+            int n = static_cast<int>(frac_part);
+
+            if (zero_digits) {
+                if (n == 0)
+                    frac_zeros++;
+                else
+                    zero_digits = false;
+            }
+
+            if (!zero_digits)
+                s += static_cast<char>('0' + n);
+
+            frac_part -= n;
+            frac_digits++;
+        }
+    }
+
+    // print exponent
+    if (fmt != SC_F) {
+        if (frac_digits == 0)
+            scfx_print_exp(s, int_zeros);
+        else if (int_digits == 0)
+            scfx_print_exp(s, -frac_zeros);
+    }
+}
+
+static void
+print_other(scfx_string &s, const scfx_ieee_double &id, sc_numrep numrep,
+             int w_prefix, sc_fmt fmt, const scfx_params *params)
+{
+    scfx_ieee_double id2 = id;
+
+    sc_numrep numrep2 = numrep;
+
+    bool numrep_is_sm = (numrep == SC_BIN_SM ||
+                         numrep == SC_OCT_SM ||
+                         numrep == SC_HEX_SM);
+
+    if (numrep_is_sm) {
+        if (id2.negative() != 0) {
+            s += '-';
+            id2.negative(0);
+        }
+        switch (numrep) {
+          case SC_BIN_SM:
+            numrep2 = SC_BIN_US;
+            break;
+          case SC_OCT_SM:
+            numrep2 = SC_OCT_US;
+            break;
+          case SC_HEX_SM:
+            numrep2 = SC_HEX_US;
+            break;
+          default:
+            ;
+        }
+    }
+
+    if (w_prefix != 0) {
+        scfx_print_prefix(s, numrep);
+    }
+
+    numrep = numrep2;
+
+    sc_fxval_fast a(id2);
+
+    int msb, lsb;
+
+    if (params != 0) {
+        msb = params->iwl() - 1;
+        lsb = params->iwl() - params->wl();
+
+        if (params->enc() == SC_TC_ &&
+            (numrep == SC_BIN_US ||
+              numrep == SC_OCT_US ||
+              numrep == SC_HEX_US) &&
+            !numrep_is_sm &&
+            params->wl() > 1) {
+            --msb;
+        } else if (params->enc() == SC_US_ &&
+            (numrep == SC_BIN ||
+              numrep == SC_OCT ||
+              numrep == SC_HEX ||
+              numrep == SC_CSD)) {
+            ++msb;
+        }
+    } else {
+        if (a.is_zero()) {
+            msb = 0;
+            lsb = 0;
+        } else {
+            msb = id2.exponent() + 1;
+            while (a.get_bit(msb) == a.get_bit(msb - 1))
+                --msb;
+
+            if (numrep == SC_BIN_US ||
+                numrep == SC_OCT_US ||
+                numrep == SC_HEX_US) {
+                --msb;
+            }
+
+            lsb = id2.exponent() - 52;
+            while (!a.get_bit(lsb))
+                ++lsb;
+        }
+    }
+
+    int step;
+
+    switch (numrep) {
+      case SC_BIN:
+      case SC_BIN_US:
+      case SC_CSD:
+        step = 1;
+       break;
+      case SC_OCT:
+      case SC_OCT_US:
+        step = 3;
+        break;
+      case SC_HEX:
+      case SC_HEX_US:
+        step = 4;
+        break;
+      default:
+        SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep");
+        sc_core::sc_abort();
+    }
+
+    msb = (int)std::ceil(double(msb + 1) / step) * step - 1;
+
+    lsb = (int)std::floor(double(lsb) / step) * step;
+
+    if (msb < 0) {
+        s += '.';
+        if (fmt == SC_F) {
+            int sign = (id2.negative() != 0) ? (1 << step) - 1 : 0;
+            for (int i = (msb + 1) / step; i < 0; i++) {
+                if (sign < 10)
+                    s += static_cast<char>(sign + '0');
+                else
+                    s += static_cast<char>(sign + 'a' - 10);
+            }
+        }
+    }
+
+    int i = msb;
+    while (i >= lsb) {
+        int value = 0;
+        for (int j = step - 1; j >= 0; --j) {
+            value += static_cast<int>(a.get_bit(i)) << j;
+            --i;
+        }
+        if (value < 10)
+            s += static_cast<char>(value + '0');
+        else
+            s += static_cast<char>(value + 'a' - 10);
+        if (i == -1)
+            s += '.';
+    }
+
+    if (lsb > 0 && fmt == SC_F) {
+        for (int i = lsb / step; i > 0; i--)
+            s += '0';
+    }
+
+    if (s[s.length() - 1] == '.')
+        s.discard(1);
+
+    if (fmt != SC_F) {
+        if (msb < 0)
+            scfx_print_exp(s, (msb + 1) / step);
+        else if (lsb > 0)
+            scfx_print_exp(s, lsb / step);
+    }
+
+    if (numrep == SC_CSD)
+        scfx_tc2csd(s, w_prefix);
+}
+
+const char *
+to_string(const scfx_ieee_double &id, sc_numrep numrep, int w_prefix,
+          sc_fmt fmt, const scfx_params *params=0)
+{
+    static scfx_string s;
+
+    s.clear();
+
+    if (id.is_nan()) {
+        scfx_print_nan(s);
+    } else if (id.is_inf()) {
+        scfx_print_inf(s, static_cast<bool>(id.negative()));
+    } else if (id.negative() && !id.is_zero() &&
+             (numrep == SC_BIN_US ||
+               numrep == SC_OCT_US ||
+               numrep == SC_HEX_US)) {
+        s += "negative";
+    } else if (numrep == SC_DEC) {
+        sc_dt::print_dec(s, id, w_prefix, fmt);
+    } else {
+        sc_dt::print_other(s, id, numrep, w_prefix, fmt, params);
+    }
+
+    return s;
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_fxval_fast::to_string() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                       SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, fmt));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, fmt));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                                        fmt));
+}
+
+const std::string
+sc_fxval_fast::to_dec() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_bin() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_BIN, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_oct() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_OCT, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_hex() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_HEX, -1, SC_E));
+}
+
+
+// print or dump content
+
+void
+sc_fxval_fast::print(::std::ostream &os) const
+{
+    os << sc_dt::to_string(m_val, SC_DEC, -1, SC_E);
+}
+
+void
+sc_fxval_fast::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval_fast::dump(::std::ostream &os) const
+{
+    os << "sc_fxval_fast" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "val = " << m_val << ::std::endl;
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// internal use only;
+bool
+sc_fxval_fast::get_bit(int i) const
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_zero() || id.is_nan() || id.is_inf())
+        return false;
+
+    // convert to two's complement
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if (id.is_normal())
+        m0 += 1U << 20;
+
+    if (id.negative() != 0) {
+        m0 = ~ m0;
+        m1 = ~ m1;
+        unsigned int tmp = m1;
+        m1 += 1U;
+        if (m1 <= tmp)
+            m0 += 1U;
+    }
+
+    // get the right bit
+    int j = i - id.exponent();
+    if ((j += 20) >= 32)
+        return ((m0 & 1U << 31) != 0);
+    else if (j >= 0)
+        return ((m0 & 1U << j) != 0);
+    else if ((j += 32) >= 0)
+        return ((m1 & 1U << j) != 0);
+    else
+        return false;
+}
+
+
+// protected methods and friend functions
+sc_fxval_fast_observer *
+sc_fxval_fast::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxval_fast_observer *tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval_fast::unlock_observer(sc_fxval_fast_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+#define SCFX_FAIL_IF_(cnd)                                                    \
+{                                                                             \
+    if ((cnd))                                                             \
+        return static_cast<double>(scfx_ieee_double::nan());                \
+}
+
+double
+sc_fxval_fast::from_string(const char *s)
+{
+    SCFX_FAIL_IF_(s == 0 || *s == 0);
+
+    scfx_string s2;
+    s2 += s;
+    s2 += '\0';
+
+    bool sign_char;
+    int sign = scfx_parse_sign(s, sign_char);
+
+    sc_numrep numrep = scfx_parse_prefix(s);
+
+    int base = 0;
+
+    switch (numrep) {
+      case SC_DEC:
+        {
+            base = 10;
+            if (scfx_is_nan(s)) // special case: NaN
+                return static_cast<double>(scfx_ieee_double::nan());
+            if (scfx_is_inf(s)) // special case: Infinity
+                return static_cast<double>(scfx_ieee_double::inf(sign));
+            break;
+        }
+      case SC_BIN:
+      case SC_BIN_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            break;
+        }
+
+      case SC_BIN_SM:
+        {
+            base = 2;
+            break;
+        }
+      case SC_OCT:
+      case SC_OCT_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 8;
+            break;
+        }
+      case SC_OCT_SM:
+        {
+            base = 8;
+            break;
+        }
+      case SC_HEX:
+      case SC_HEX_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 16;
+            break;
+        }
+      case SC_HEX_SM:
+        {
+            base = 16;
+            break;
+        }
+      case SC_CSD:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            scfx_csd2tc(s2);
+            s = (const char*) s2 + 4;
+            numrep = SC_BIN;
+            break;
+        }
+      default:;// Martin, what is default???
+    }
+
+    //
+    // find end of mantissa and count the digits and points
+    //
+
+    const char *end = s;
+    bool based_point = false;
+    int int_digits = 0;
+    int frac_digits = 0;
+
+    while (*end) {
+        if (scfx_exp_start(end))
+            break;
+
+        if (*end == '.') {
+            SCFX_FAIL_IF_(based_point);
+            based_point = true;
+        } else {
+            SCFX_FAIL_IF_(!scfx_is_digit(*end, numrep));
+            if (based_point)
+                frac_digits++;
+            else
+                int_digits++;
+        }
+
+        end++;
+    }
+
+    SCFX_FAIL_IF_(int_digits == 0 && frac_digits == 0);
+
+    // [ exponent ]
+    int exponent = 0;
+    if (*end) {
+        for (const char *e = end + 2; *e; e++)
+            SCFX_FAIL_IF_(!scfx_is_digit(*e, SC_DEC));
+        exponent = std::atoi(end + 1);
+    }
+
+    //
+    // convert the mantissa
+    //
+    double integer = 0.0;
+    if (int_digits != 0) {
+        bool first_digit = true;
+
+        for (; s < end; s++) {
+            if (*s == '.')
+                break;
+
+            if (first_digit) {
+                integer = scfx_to_digit(*s, numrep);
+                switch (numrep) {
+                  case SC_BIN:
+                  case SC_OCT:
+                  case SC_HEX:
+                    {
+                        if (integer >= (base >> 1))
+                            integer -= base; // two's complement
+                        break;
+                    }
+                  default:
+                    ;
+                }
+                first_digit = false;
+            } else {
+                integer *= base;
+                integer += scfx_to_digit(*s, numrep);
+            }
+        }
+    }
+
+    // [ . fraction ]
+    double fraction = 0.0;
+    if (frac_digits != 0) {
+        s++;  // skip '.'
+
+        bool first_digit = (int_digits == 0);
+        double scale = 1.0;
+        for (; s < end; s++) {
+            scale /= base;
+
+            if (first_digit) {
+                fraction = scfx_to_digit(*s, numrep);
+                switch (numrep) {
+                  case SC_BIN:
+                  case SC_OCT:
+                  case SC_HEX:
+                    {
+                        if (fraction >= (base >> 1))
+                            fraction -= base; // two's complement
+                        break;
+                    }
+                  default:
+                    ;
+                }
+                fraction *= scale;
+                first_digit = false;
+            } else {
+                fraction += scfx_to_digit(*s, numrep) * scale;
+            }
+        }
+    }
+
+    double exp =
+        (exponent != 0) ? std::pow((double) base, (double) exponent) : 1;
+
+    return (sign * (integer + fraction) * exp);
+}
+
+#undef SCFX_FAIL_IF_
+
+} // namespace sc_dt