diff --git a/src/base/stl_helpers.hh b/src/base/stl_helpers.hh
index 1d19f56..b70eea9 100644
--- a/src/base/stl_helpers.hh
+++ b/src/base/stl_helpers.hh
@@ -26,59 +26,10 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __BASE_STL_HELPERS_HH__
-#define __BASE_STL_HELPERS_HH__
+#ifndef BASE_STL_HELPERS_HH
+#define BASE_STL_HELPERS_HH
 
-#include <algorithm>
-#include <iostream>
-#include <numeric>
-#include <type_traits>
-#include <vector>
-
-#include "base/compiler.hh"
 #include "base/stl_helpers/hash_helpers.hh"
+#include "base/stl_helpers/ostream_helpers.hh"
 
-namespace gem5
-{
-
-namespace stl_helpers
-{
-
-template <typename T, typename Enabled=void>
-struct IsHelpedContainer : public std::false_type {};
-
-template <typename ...Types>
-struct IsHelpedContainer<std::vector<Types...>> : public std::true_type {};
-
-template <typename ...Types>
-constexpr bool IsHelpedContainerV = IsHelpedContainer<Types...>::value;
-
-/**
- * Write out all elements in an stl container as a space separated
- * list enclosed in square brackets
- *
- * @ingroup api_base_utils
- */
-
-template <typename T>
-std::enable_if_t<IsHelpedContainerV<T>, std::ostream &>
-operator<<(std::ostream& out, const T &t)
-{
-    out << "[ ";
-    bool first = true;
-    auto printer = [&first, &out](const auto &elem) {
-        if (first)
-            out << elem;
-        else
-            out << " " << elem;
-    };
-    std::for_each(t.begin(), t.end(), printer);
-    out << " ]";
-    out << std::flush;
-    return out;
-}
-
-} // namespace stl_helpers
-} // namespace gem5
-
-#endif // __BASE_STL_HELPERS_HH__
+#endif // BASE_STL_HELPERS_HH
diff --git a/src/base/stl_helpers/SConscript b/src/base/stl_helpers/SConscript
index 1143dc2..7328cf0 100644
--- a/src/base/stl_helpers/SConscript
+++ b/src/base/stl_helpers/SConscript
@@ -26,3 +26,4 @@
 Import('*')
 
 GTest('hash_helpers.test', 'hash_helpers.test.cc')
+GTest('ostream_helpers.test', 'ostream_helpers.test.cc')
diff --git a/src/base/stl_helpers/ostream_helpers.hh b/src/base/stl_helpers/ostream_helpers.hh
new file mode 100644
index 0000000..a1c92e1
--- /dev/null
+++ b/src/base/stl_helpers/ostream_helpers.hh
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2023 Arteris, Inc. and its applicable licensors and
+ * affiliates.
+ * All rights reserved.
+ *
+ * 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.
+ */
+
+#ifndef BASE_STL_HELPERS_OSTREAM_HELPERS_HH
+#define BASE_STL_HELPERS_OSTREAM_HELPERS_HH
+
+#include <iostream>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "base/type_traits.hh"
+#include "magic_enum/magic_enum.hh"
+
+namespace gem5::stl_helpers
+{
+
+namespace opExtract_impl
+{
+
+/*
+ * In order to provide a specialization for operator<< with stl_helpers-enabled
+ * types
+ * without loosing the hability to use it with other types, a dual-dispatch
+ * mechanism is used. The only entry point in the system is through a primary
+ * dispatch function that won't resolve for non-helped types. Then, recursive
+ * calls go through the secondary dispatch interface that sort between helped
+ * and non-helped types. Helped typed will enter the system back through the
+ * primary dispatch interface while other types will look for operator<<
+ * through regular lookup, especially ADL.
+ */
+
+template<typename T>
+std::ostream&
+opExtractSecDisp(std::ostream& os, const T& v);
+
+template <typename E>
+std::enable_if_t<std::is_enum_v<E>,
+std::ostream&>
+opExtractPrimDisp(std::ostream& os, const E& e)
+{
+    return os << magic_enum::enum_name(e);
+}
+
+template <typename... T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, const std::tuple<T...>& p)
+{
+    std::apply([&](auto&&... e) {
+        std::size_t n{0};
+        os << '(';
+        ((opExtractSecDisp(os, e) << (++n != sizeof...(T) ? ", " : "")), ...);
+        os << ')';
+    }, p);
+    return os;
+}
+
+template <typename T, typename U>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, const std::pair<T, U>& p)
+{
+    return opExtractPrimDisp(os, std::tie(p.first, p.second));
+}
+
+template <typename T>
+std::enable_if_t<is_iterable_v<T>, std::ostream&>
+opExtractPrimDisp(std::ostream& os, const T& v)
+{
+    os << "[ ";
+    for (auto& e: v) {
+        opExtractSecDisp(os, e) << ", ";
+    }
+    return os << ']';
+}
+
+template <typename T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, const std::optional<T>& o)
+{
+    if (o) {
+        return opExtractSecDisp(os, *o);
+    } else {
+        return os << '-';
+    }
+}
+
+template <typename T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, T* p);
+
+template <typename T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, const std::shared_ptr<T>& p)
+{
+    return opExtractPrimDisp(os, p.get());
+}
+
+template <typename T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, const std::unique_ptr<T>& p)
+{
+    return opExtractPrimDisp(os, p.get());
+}
+
+template <typename, typename = void>
+constexpr bool isOpExtractNativelySupported = false;
+
+template <typename T>
+constexpr bool isOpExtractNativelySupported<T,
+    std::void_t<decltype(
+        std::declval<std::ostream&>() << std::declval<T>())>> = true;
+
+template <typename, typename = void>
+constexpr bool isOpExtractHelped = false;
+
+template <typename T>
+constexpr bool isOpExtractHelped<T,
+    std::void_t<decltype(
+        opExtractPrimDisp(std::declval<std::ostream&>(),
+                          std::declval<T>()))>>
+    = true;
+
+template <typename T>
+constexpr bool needsDispatch =
+    isOpExtractHelped<T> && !isOpExtractNativelySupported<T>;
+
+template <typename T>
+std::ostream&
+opExtractPrimDisp(std::ostream& os, T* p)
+{
+    if (!p) {
+        return os << "nullptr";
+    }
+    if constexpr (isOpExtractHelped<T> || isOpExtractNativelySupported<T>) {
+        os << '(' << p << ": ";
+        opExtractSecDisp(os, *p);
+        return os << ')';
+    } else {
+        return os << p;
+    }
+}
+
+template<typename T>
+std::ostream&
+opExtractSecDisp(std::ostream& os, const T& v)
+{
+    if constexpr (needsDispatch<T>) {
+        return opExtractPrimDisp(os, v);
+    } else {
+        return os << v;
+    }
+}
+
+} // namespace opExtract_impl
+
+// Add "using stl_helpers::operator<<" in the scope where you want to use it.
+template<typename T>
+std::enable_if_t<opExtract_impl::needsDispatch<T>, std::ostream&>
+operator<<(std::ostream& os, const T& v)
+{
+    return opExtract_impl::opExtractPrimDisp(os, v);
+}
+
+} // namespace gem5::stl_helpers
+
+#endif // BASE_STL_HELPERS_OSTREAM_HELPERS_HH
diff --git a/src/base/stl_helpers/ostream_helpers.test.cc b/src/base/stl_helpers/ostream_helpers.test.cc
new file mode 100644
index 0000000..19a1ece
--- /dev/null
+++ b/src/base/stl_helpers/ostream_helpers.test.cc
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2023 Arteris, Inc. and its applicable licensors and
+ * affiliates.  All rights reserved.
+ *
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+
+#include <map>
+#include <sstream>
+#include <string_view>
+#include <vector>
+
+#include "base/stl_helpers/ostream_helpers.hh"
+
+using gem5::stl_helpers::operator<<;
+
+TEST(OstreamHelpers, pair) {
+    auto p = std::make_pair(1, 2);
+    std::ostringstream os;
+    os << p;
+    EXPECT_EQ(os.str(), "(1, 2)");
+}
+
+TEST(OstreamHelpers, tuple) {
+    auto t = std::make_tuple(true,
+        std::make_pair("Hello", std::string_view("World")), '!');
+    std::ostringstream os;
+    os << t;
+    EXPECT_EQ(os.str(), "(1, (Hello, World), !)");
+}
+
+TEST(OstreamHelpers, vector) {
+    auto v = std::vector<const char*>{"abc", "defg", "hijklm", "\n"};
+    std::ostringstream os;
+    os << v;
+    EXPECT_EQ(os.str(), "[ abc, defg, hijklm, \n, ]");
+}
+
+TEST(OstreamHelpers, map) {
+    auto m = std::map<char, int>{{'a', 0}, {'b', 1}, {'c', 2}, {'d', 3}};
+    std::ostringstream os;
+    os << m;
+    EXPECT_EQ(os.str(), "[ (a, 0), (b, 1), (c, 2), (d, 3), ]");
+}