base: Reimplement the DPRINTF mechanism in a Logger class

This patch adds a Logger class encapsulating dprintf.  This allows
variants of DPRINTF logging to be constructed and substituted in
place of the default behaviour.

The Logger provides a logMessage(when, name, format, ...) member
function like Trace::dprintf and a getOstream member function to
use a raw ostream for logging.

A class OstreamLogger is provided which generates the customary
debugging output with Trace::OstreamLogger::logMessage being the
old Trace::dprintf.

1 files changed, 97 insertions, 53 deletions

diff --git a/src/base/trace.hh b/src/base/trace.hh
index 3e6e37bd3..70e85bf35 100644
--- a/src/base/trace.hh
+++ b/src/base/trace.hh
@@ -2,15 +2,6 @@
  * Copyright (c) 2014 ARM Limited
  * All rights reserved
  *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder.  You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
  * Copyright (c) 2001-2006 The Regents of The University of Michigan
  * All rights reserved.
  *
@@ -39,6 +30,7 @@
  *
  * Authors: Nathan Binkert
  *          Steve Reinhardt
+ *          Andrew Bardsley
  */
 
 #ifndef __BASE_TRACE_HH__
@@ -54,34 +46,78 @@
 
 namespace Trace {
 
-using Debug::SimpleFlag;
-using Debug::CompoundFlag;
+/** Debug logging base class.  Handles formatting and outputting
+ *  time/name/message messages */
+class Logger
+{
+  protected:
+    /** Name match for objects to ignore */
+    ObjectMatch ignore;
 
-std::ostream &output();
-void setOutput(const std::string &filename);
+  public:
+    /** Log a single message */
+    template <typename ...Args>
+    void dprintf(Tick when, const std::string &name, const char *fmt,
+                 const Args &...args)
+    {
+        if (!name.empty() && ignore.match(name))
+            return;
+
+        std::ostringstream line;
+        ccprintf(line, fmt, args...);
+        logMessage(when, name, line.str());
+    }
+
+    /** Dump a block of data of length len */
+    virtual void dump(Tick when, const std::string &name,
+                      const void *d, int len);
+
+    /** Log formatted message */
+    virtual void logMessage(Tick when, const std::string &name,
+                            const std::string &message) = 0;
+
+    /** Return an ostream that can be used to send messages to
+     *  the 'same place' as formatted logMessage messages.  This
+     *  can be implemented to use a logger's underlying ostream,
+     *  to provide an ostream which formats the output in some
+     *  way, or just set to one of std::cout, std::cerr */
+    virtual std::ostream &getOstream() = 0;
+
+    /** Set objects to ignore */
+    void setIgnore(ObjectMatch &ignore_) { ignore = ignore_; }
+
+    virtual ~Logger() { }
+};
 
-extern bool enabled;
-bool changeFlag(const char *str, bool value);
-void dumpStatus();
+/** Logging wrapper for ostreams with the format:
+ *  <when>: <name>: <message-body> */
+class OstreamLogger : public Logger
+{
+  protected:
+    std::ostream &stream;
 
-extern ObjectMatch ignore;
-extern const std::string DefaultName;
+  public:
+    OstreamLogger(std::ostream &stream_) : stream(stream_)
+    { }
 
-bool __dprintf_prologue(Tick when, const std::string &name);
+    void logMessage(Tick when, const std::string &name,
+                    const std::string &message) M5_ATTR_OVERRIDE;
 
-template<typename ...Args> void
-dprintf(Tick when, const std::string &name, const char *format,
-        const Args &...args)
-{
-    if (!__dprintf_prologue(when, name))
-        return;
+    std::ostream &getOstream() M5_ATTR_OVERRIDE { return stream; }
+};
 
-    std::ostream &os(output());
-    ccprintf(os, format, args...);
-    os.flush();
-}
+/** Get the current global debug logger.  This takes ownership of the given
+ *  logger which should be allocated using 'new' */
+Logger *getDebugLogger();
 
-void dump(Tick when, const std::string &name, const void *data, int len);
+/** Get the ostream from the current global logger */
+std::ostream &output();
+
+/** Delete the current global logger and assign a new one */
+void setDebugLogger(Logger *logger);
+
+/** Enable debug logging */
+extern bool enabled;
 
 } // namespace Trace
 
@@ -94,7 +130,9 @@ struct StringWrap
     const std::string &operator()() const { return str; }
 };
 
-inline const std::string &name() { return Trace::DefaultName; }
+// Return the global context name "global".  This function gets called when
+// the DPRINTF macros are used in a context without a visible name() function
+const std::string &name();
 
 // Interface for things with names. (cf. SimObject but without other
 // functionality).  This is useful when using DPRINTF
@@ -124,40 +162,46 @@ class Named
 
 #define DTRACE(x) ((Debug::x) && Trace::enabled)
 
-#define DDUMP(x, data, count) do {                              \
-    using namespace Debug;                                      \
-    if (DTRACE(x))                                              \
-        Trace::dump(curTick(), name(), data, count);              \
+#define DDUMP(x, data, count) do {                                        \
+    using namespace Debug;                                                \
+    if (DTRACE(x))                                                        \
+        Trace::getDebugLogger()->dump(curTick(), name(), data, count);    \
 } while (0)
 
-#define DPRINTF(x, ...) do {                                    \
-    using namespace Debug;                                      \
-    if (DTRACE(x))                                              \
-        Trace::dprintf(curTick(), name(), __VA_ARGS__);           \
+#define DPRINTF(x, ...) do {                                              \
+    using namespace Debug;                                                \
+    if (DTRACE(x)) {                                                      \
+        Trace::getDebugLogger()->dprintf(curTick(), name(),               \
+            __VA_ARGS__);                                                 \
+    }                                                                     \
 } while (0)
 
-#define DPRINTFS(x, s, ...) do {                                \
-    using namespace Debug;                                      \
-    if (DTRACE(x))                                              \
-        Trace::dprintf(curTick(), s->name(), __VA_ARGS__);      \
+#define DPRINTFS(x, s, ...) do {                                          \
+    using namespace Debug;                                                \
+    if (DTRACE(x)) {                                                      \
+        Trace::getDebugLogger()->dprintf(curTick(), s->name(),            \
+            __VA_ARGS__);                                                 \
+    }                                                                     \
 } while (0)
 
-#define DPRINTFR(x, ...) do {                                   \
-    using namespace Debug;                                      \
-    if (DTRACE(x))                                              \
-        Trace::dprintf((Tick)-1, std::string(), __VA_ARGS__);   \
+#define DPRINTFR(x, ...) do {                                             \
+    using namespace Debug;                                                \
+    if (DTRACE(x)) {                                                      \
+        Trace::getDebugLogger()->dprintf((Tick)-1, std::string(),         \
+            __VA_ARGS__);                                                 \
+    }                                                                     \
 } while (0)
 
-#define DDUMPN(data, count) do {                                \
-    Trace::dump(curTick(), name(), data, count);                  \
+#define DDUMPN(data, count) do {                                          \
+    Trace::getDebugLogger()->dump(curTick(), name(), data, count);        \
 } while (0)
 
-#define DPRINTFN(...) do {                                      \
-    Trace::dprintf(curTick(), name(), __VA_ARGS__);               \
+#define DPRINTFN(...) do {                                                \
+    Trace::getDebugLogger()->dprintf(curTick(), name(), __VA_ARGS__);     \
 } while (0)
 
-#define DPRINTFNR(...) do {                                     \
-    Trace::dprintf((Tick)-1, string(), __VA_ARGS__);            \
+#define DPRINTFNR(...) do {                                               \
+    Trace::getDebugLogger()->dprintf((Tick)-1, string(), __VA_ARGS__);    \
 } while (0)
 
 #else // !TRACING_ON