systemc: Remove redundant tlm_ prefixes from file names.

We already know those files belong to tlm because of the directory
they're in. Removing the prefix makes the paths of the headers less
enormously long.

Change-Id: I869e58fae904162f353bb31f4c0919fba08dffa6
Reviewed-on: https://gem5-review.googlesource.com/c/15059
Reviewed-by: Anthony Gutierrez <anthony.gutierrez@amd.com>
Maintainer: Anthony Gutierrez <anthony.gutierrez@amd.com>

5 files changed, 578 insertions, 0 deletions

diff --git a/src/systemc/tlm_core/2/generic_payload/SConscript b/src/systemc/tlm_core/2/generic_payload/SConscript
new file mode 100644
index 000000000..bea993450
--- /dev/null
+++ b/src/systemc/tlm_core/2/generic_payload/SConscript
@@ -0,0 +1,32 @@
+# 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('gp.cc')
+    Source('phase.cc')
diff --git a/src/systemc/tlm_core/2/generic_payload/gp.cc b/src/systemc/tlm_core/2/generic_payload/gp.cc
new file mode 100644
index 000000000..ff3c92bd9
--- /dev/null
+++ b/src/systemc/tlm_core/2/generic_payload/gp.cc
@@ -0,0 +1,355 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#include <cstring>  // std::memcpy et.al.
+#include <map>
+#include <systemc>
+#include <tlm>
+
+using sc_core::sc_type_index;
+
+namespace tlm
+{
+
+template class tlm_array<tlm_extension_base *>;
+
+//---------------------------------------------------------------------------
+// Classes for the extension mechanism
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+class tlm_extension_registry
+{
+    typedef unsigned int key_type;
+    typedef std::map<sc_core::sc_type_index, key_type> type_map;
+  public:
+    static tlm_extension_registry &
+    instance()
+    {
+        if (!instance_) {
+            // Don't cleanup registry.
+            instance_ = new tlm_extension_registry();
+        }
+        return *instance_;
+    }
+
+    unsigned int
+    register_extension(sc_type_index type)
+    {
+        type_map::const_iterator it = ids_.find(type);
+
+        if (it == ids_.end()) {
+            // New extension - generate/store ID.
+            type_map::value_type v(type, static_cast<key_type>(ids_.size()));
+            ids_.insert(v);
+            return v.second;
+        }
+        return it->second;
+    }
+
+    static unsigned int
+    max_num_extensions()
+    {
+        return (instance_) ? instance().ids_.size() : 0;
+    }
+
+  private:
+    static tlm_extension_registry *instance_;
+    type_map ids_;
+    tlm_extension_registry() {}
+
+};
+
+tlm_extension_registry *tlm_extension_registry::instance_ = NULL;
+
+} // anonymous namespace
+
+unsigned int
+max_num_extensions()
+{
+    return tlm_extension_registry::max_num_extensions();
+}
+
+unsigned int
+tlm_extension_base::register_extension(const std::type_info &type)
+{
+    return tlm_extension_registry::instance().register_extension(type);
+}
+
+//---------------------------------------------------------------------------
+// The generic payload class:
+//---------------------------------------------------------------------------
+
+tlm_generic_payload::tlm_generic_payload() : m_address(0),
+    m_command(TLM_IGNORE_COMMAND), m_data(0), m_length(0),
+    m_response_status(TLM_INCOMPLETE_RESPONSE), m_dmi(false), m_byte_enable(0),
+    m_byte_enable_length(0), m_streaming_width(0),
+    m_gp_option(TLM_MIN_PAYLOAD), m_extensions(max_num_extensions()), m_mm(0),
+    m_ref_count(0)
+{}
+
+tlm_generic_payload::tlm_generic_payload(tlm_mm_interface *mm): m_address(0),
+    m_command(TLM_IGNORE_COMMAND), m_data(0), m_length(0),
+    m_response_status(TLM_INCOMPLETE_RESPONSE), m_dmi(false), m_byte_enable(0),
+    m_byte_enable_length(0), m_streaming_width(0),
+    m_gp_option(TLM_MIN_PAYLOAD), m_extensions(max_num_extensions()), m_mm(mm),
+    m_ref_count(0)
+{}
+
+void
+tlm_generic_payload::reset()
+{
+    // Should the other members be reset too?
+    m_gp_option = TLM_MIN_PAYLOAD;
+    m_extensions.free_entire_cache();
+};
+
+// Non-virtual deep-copying of the object.
+void
+tlm_generic_payload::deep_copy_from(const tlm_generic_payload &other)
+{
+    m_command = other.get_command();
+    m_address = other.get_address();
+    m_length = other.get_data_length();
+    m_response_status = other.get_response_status();
+    m_byte_enable_length = other.get_byte_enable_length();
+    m_streaming_width = other.get_streaming_width();
+    m_gp_option = other.get_gp_option();
+    m_dmi = other.is_dmi_allowed();
+
+    // Deep copy data.
+    // There must be enough space in the target transaction!
+    if (m_data && other.m_data) {
+        std::memcpy(m_data, other.m_data, m_length);
+    }
+    // Deep copy byte enables.
+    // There must be enough space in the target transaction!
+    if (m_byte_enable && other.m_byte_enable) {
+        std::memcpy(m_byte_enable, other.m_byte_enable, m_byte_enable_length);
+    }
+    // Deep copy extensions (sticky and non-sticky).
+    if (m_extensions.size() < other.m_extensions.size()) {
+        m_extensions.expand(other.m_extensions.size());
+    }
+    for (unsigned int i = 0; i < other.m_extensions.size(); i++) {
+        if (other.m_extensions[i]) {
+            // Original has extension i.
+            if (!m_extensions[i]) {
+                // We don't: clone.
+                tlm_extension_base *ext = other.m_extensions[i]->clone();
+                if (ext) { // Extension may not be clonable.
+                    if (has_mm()) {
+                        // mm can take care of removing cloned extensions.
+                        set_auto_extension(i, ext);
+                    } else {
+                        // no mm, user will call free_all_extensions().
+                        set_extension(i, ext);
+                    }
+                }
+            } else {
+                // We already have such extension. Copy original over it.
+                m_extensions[i]->copy_from(*other.m_extensions[i]);
+            }
+        }
+    }
+}
+
+// To update the state of the original generic payload from a deep copy.
+// Assumes that "other" was created from the original by calling
+// deep_copy_from. Argument use_byte_enable_on_read determines whether to use
+// or ignores byte enables when copying back the data array on a read command.
+
+void
+tlm_generic_payload::update_original_from(
+        const tlm_generic_payload &other, bool use_byte_enable_on_read)
+{
+    // Copy back extensions that are present on the original.
+    update_extensions_from(other);
+
+    // Copy back the response status and DMI hint attributes.
+    m_response_status = other.get_response_status();
+    m_dmi = other.is_dmi_allowed();
+
+    // Copy back the data array for a read command only deep_copy_from allowed
+    // null pointers, and so will we.
+    // We assume the arrays are the same size.
+    // We test for equal pointers in case the original and the copy share the
+    // same array.
+
+    if (is_read() && m_data && other.m_data && m_data != other.m_data) {
+        if (m_byte_enable && use_byte_enable_on_read) {
+            if (m_byte_enable_length == 8 && m_length % 8 == 0) {
+                // Optimized implementation copies 64-bit words by masking.
+                for (unsigned int i = 0; i < m_length; i += 8) {
+                    typedef sc_dt::uint64 *u;
+                    *reinterpret_cast<u>(&m_data[i]) &=
+                        ~*reinterpret_cast<u>(m_byte_enable);
+                    *reinterpret_cast<u>(&m_data[i]) |=
+                        *reinterpret_cast<u>(&other.m_data[i]) &
+                        *reinterpret_cast<u>(m_byte_enable);
+                }
+            } else if (m_byte_enable_length == 4 && m_length % 4 == 0) {
+                // Optimized implementation copies 32-bit words by masking.
+                for (unsigned int i = 0; i < m_length; i += 4) {
+                    typedef unsigned int *u;
+                    *reinterpret_cast<u>(&m_data[i]) &=
+                        ~*reinterpret_cast<u>(m_byte_enable);
+                    *reinterpret_cast<u>(&m_data[i]) |=
+                        *reinterpret_cast<u>(&other.m_data[i]) &
+                        *reinterpret_cast<u>(m_byte_enable);
+                }
+            } else {
+                // Unoptimized implementation.
+                for (unsigned int i = 0; i < m_length; i++) {
+                    if (m_byte_enable[i % m_byte_enable_length])
+                        m_data[i] = other.m_data[i];
+                }
+            }
+        } else {
+            std::memcpy(m_data, other.m_data, m_length);
+        }
+    }
+}
+
+void
+tlm_generic_payload::update_extensions_from(const tlm_generic_payload &other)
+{
+    // Deep copy extensions that are already present.
+    sc_assert(m_extensions.size() <= other.m_extensions.size());
+    for (unsigned int i = 0; i < m_extensions.size(); i++) {
+        if (other.m_extensions[i]) {
+            // Original has extension i.
+            if (m_extensions[i]) {
+                // We have it too. Copy.
+                m_extensions[i]->copy_from(*other.m_extensions[i]);
+            }
+        }
+    }
+}
+
+// Free all extensions. Useful when reusing a cloned transaction that doesn't
+// have memory manager. Normal and sticky extensions are freed and extension
+// array cleared.
+void
+tlm_generic_payload::free_all_extensions()
+{
+    m_extensions.free_entire_cache();
+    for (unsigned int i = 0; i < m_extensions.size(); i++) {
+        if (m_extensions[i]) {
+            m_extensions[i]->free();
+            m_extensions[i] = 0;
+        }
+    }
+}
+
+tlm_generic_payload::~tlm_generic_payload()
+{
+    for (unsigned int i = 0; i < m_extensions.size(); i++) {
+        if (m_extensions[i])
+            m_extensions[i]->free();
+    }
+}
+
+//----------------
+// API (including setters & getters)
+//---------------
+
+std::string
+tlm_generic_payload::get_response_string() const
+{
+    switch (m_response_status) {
+      case TLM_OK_RESPONSE:
+        return "TLM_OK_RESPONSE";
+      case TLM_INCOMPLETE_RESPONSE:
+        return "TLM_INCOMPLETE_RESPONSE";
+      case TLM_GENERIC_ERROR_RESPONSE:
+        return "TLM_GENERIC_ERROR_RESPONSE";
+      case TLM_ADDRESS_ERROR_RESPONSE:
+        return "TLM_ADDRESS_ERROR_RESPONSE";
+      case TLM_COMMAND_ERROR_RESPONSE:
+        return "TLM_COMMAND_ERROR_RESPONSE";
+      case TLM_BURST_ERROR_RESPONSE:
+        return "TLM_BURST_ERROR_RESPONSE";
+      case TLM_BYTE_ENABLE_ERROR_RESPONSE:
+        return "TLM_BYTE_ENABLE_ERROR_RESPONSE";
+    }
+    return "TLM_UNKNOWN_RESPONSE";
+}
+
+/* --------------------------------------------------------------------- */
+/* Dynamic extension mechanism:                                          */
+/* --------------------------------------------------------------------- */
+
+tlm_extension_base *
+tlm_generic_payload::set_extension(unsigned int index, tlm_extension_base *ext)
+{
+    sc_assert(index < m_extensions.size());
+    tlm_extension_base *tmp = m_extensions[index];
+    m_extensions[index] = ext;
+    return tmp;
+}
+
+tlm_extension_base *
+tlm_generic_payload::set_auto_extension(
+        unsigned int index, tlm_extension_base *ext)
+{
+    sc_assert(index < m_extensions.size());
+    tlm_extension_base *tmp = m_extensions[index];
+    m_extensions[index] = ext;
+    if (!tmp)
+        m_extensions.insert_in_cache(&m_extensions[index]);
+    sc_assert(m_mm != 0);
+    return tmp;
+}
+
+tlm_extension_base *
+tlm_generic_payload::get_extension(unsigned int index) const
+{
+    sc_assert(index < m_extensions.size());
+    return m_extensions[index];
+}
+
+void
+tlm_generic_payload::clear_extension(unsigned int index)
+{
+    sc_assert(index < m_extensions.size());
+    m_extensions[index] = static_cast<tlm_extension_base *>(0);
+}
+
+void
+tlm_generic_payload::release_extension(unsigned int index)
+{
+    sc_assert(index < m_extensions.size());
+    if (m_mm) {
+        m_extensions.insert_in_cache(&m_extensions[index]);
+    } else {
+        m_extensions[index]->free();
+        m_extensions[index] = static_cast<tlm_extension_base *>(nullptr);
+    }
+}
+
+void
+tlm_generic_payload::resize_extensions()
+{
+    m_extensions.expand(max_num_extensions());
+}
+
+} // namespace tlm
diff --git a/src/systemc/tlm_core/2/generic_payload/phase.cc b/src/systemc/tlm_core/2/generic_payload/phase.cc
new file mode 100644
index 000000000..2c8b1e1a0
--- /dev/null
+++ b/src/systemc/tlm_core/2/generic_payload/phase.cc
@@ -0,0 +1,111 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#include <cstring>
+#include <map>
+#include <systemc>
+#include <tlm>
+
+using sc_core::sc_string_view;
+using sc_core::sc_type_index;
+
+namespace tlm
+{
+
+namespace
+{
+
+struct tlm_phase_registry
+{
+    typedef unsigned int key_type;
+
+    static tlm_phase_registry &
+    instance()
+    {
+        static tlm_phase_registry inst;
+        return inst;
+    }
+
+    unsigned int
+    register_phase(sc_type_index type, sc_string_view name)
+    {
+        type_map::const_iterator it = ids_.find(type);
+
+        if (name.empty()) {
+            SC_REPORT_FATAL( sc_core::SC_ID_INTERNAL_ERROR_,
+                    "unexpected empty tlm_phase name" );
+            return UNINITIALIZED_PHASE;
+        }
+
+        if (it == ids_.end()) {
+            // new phase - generate/store ID and name
+            type_map::value_type v(type, static_cast<key_type>(names_.size()));
+            names_.push_back(name_table::value_type(name.data(), name.size()));
+            ids_.insert(v);
+            return v.second;
+        }
+
+        if (names_[it->second] != name) {
+            SC_REPORT_FATAL(sc_core::SC_ID_INTERNAL_ERROR_,
+                    "tlm_phase registration failed: duplicate type info" );
+            sc_core::sc_abort();
+        }
+        return it->second;
+    }
+
+    const char *
+    get_name(key_type id) const
+    {
+        sc_assert(id < names_.size());
+        return names_[id].c_str();
+    }
+
+  private:
+    typedef std::map<sc_type_index, key_type> type_map;
+    typedef std::vector<std::string> name_table;
+
+    type_map ids_;
+    name_table names_;
+
+    tlm_phase_registry() : names_(END_RESP + 1)
+    {
+        names_[UNINITIALIZED_PHASE] = "UNINITIALIZED_PHASE";
+        names_[BEGIN_REQ] = "BEGIN_REQ";
+        names_[END_REQ] = "END_REQ";
+        names_[BEGIN_RESP] = "BEGIN_RESP";
+        names_[END_RESP] = "END_RESP";
+    }
+};
+
+} // anonymous namespace
+
+tlm_phase::tlm_phase(unsigned int id) : m_id(id)
+{}
+
+tlm_phase::tlm_phase(const std::type_info &type, const char *name) :
+    m_id(tlm_phase_registry::instance().register_phase(type, name))
+{}
+
+const char *
+tlm_phase::get_name() const
+{
+    return tlm_phase_registry::instance().get_name(m_id);
+}
+
+} // namespace tlm
diff --git a/src/systemc/tlm_core/2/quantum/SConscript b/src/systemc/tlm_core/2/quantum/SConscript
new file mode 100644
index 000000000..a1580471f
--- /dev/null
+++ b/src/systemc/tlm_core/2/quantum/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('global_quantum.cc')
diff --git a/src/systemc/tlm_core/2/quantum/global_quantum.cc b/src/systemc/tlm_core/2/quantum/global_quantum.cc
new file mode 100644
index 000000000..7ba44e3cb
--- /dev/null
+++ b/src/systemc/tlm_core/2/quantum/global_quantum.cc
@@ -0,0 +1,49 @@
+/*****************************************************************************
+
+  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.
+
+ *****************************************************************************/
+
+#include <systemc>
+#include <tlm>
+
+namespace tlm
+{
+
+tlm_global_quantum::tlm_global_quantum() :
+    m_global_quantum(sc_core::SC_ZERO_TIME)
+{}
+
+tlm_global_quantum &
+tlm_global_quantum::instance()
+{
+    static tlm_global_quantum instance_;
+    return instance_;
+}
+
+sc_core::sc_time
+tlm_global_quantum::compute_local_quantum()
+{
+    if (m_global_quantum != sc_core::SC_ZERO_TIME) {
+        const sc_core::sc_time current = sc_core::sc_time_stamp();
+        const sc_core::sc_time g_quant = m_global_quantum;
+        return g_quant - (current % g_quant);
+    } else {
+        return sc_core::SC_ZERO_TIME;
+    }
+}
+
+} // namespace tlm