/*
- * Copyright (c) 2001-2005 The Regents of The University of Michigan
+ * Copyright (c) 2014, 2019 ARM Limited
+ * All rights reserved
+ *
+ * Copyright (c) 2001-2006 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* 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: Nathan Binkert
- * Steve Reinhardt
*/
#ifndef __BASE_TRACE_HH__
#define __BASE_TRACE_HH__
-#include <vector>
+#include <string>
#include "base/cprintf.hh"
+#include "base/debug.hh"
#include "base/match.hh"
-#include "sim/host.hh"
-#include "sim/root.hh"
-
-#include "base/traceflags.hh"
+#include "base/types.hh"
+#include "sim/core.hh"
namespace Trace {
- typedef std::vector<bool> FlagVec;
-
- extern FlagVec flags;
-
-#if TRACING_ON
- const bool On = true;
-#else
- const bool On = false;
-#endif
-
- inline bool
- IsOn(int t)
+/** Debug logging base class. Handles formatting and outputting
+ * time/name/message messages */
+class Logger
+{
+ protected:
+ /** Name match for objects to ignore */
+ ObjectMatch ignore;
+
+ public:
+ /** Log a single message */
+ template <typename ...Args>
+ void dprintf(Tick when, const std::string &name, const char *fmt,
+ const Args &...args)
{
- return flags[t];
-
+ dprintf_flag(when, name, "", fmt, args...);
}
- void dump(const uint8_t *data, int count);
-
- class Record
+ /** Log a single message with a flag prefix. */
+ template <typename ...Args>
+ void dprintf_flag(Tick when, const std::string &name,
+ const std::string &flag,
+ const char *fmt, const Args &...args)
{
- protected:
- Tick cycle;
-
- Record(Tick _cycle)
- : cycle(_cycle)
- {
- }
-
- public:
- virtual ~Record() {}
-
- virtual void dump(std::ostream &) = 0;
- };
-
- class PrintfRecord : public Record
- {
- private:
- const char *format;
- const std::string &name;
- cp::ArgList &args;
-
- public:
- PrintfRecord(const char *_format, cp::ArgList &_args,
- Tick cycle, const std::string &_name)
- : Record(cycle), format(_format), name(_name), args(_args)
- {
- }
+ if (!name.empty() && ignore.match(name))
+ return;
+ std::ostringstream line;
+ ccprintf(line, fmt, args...);
+ logMessage(when, name, flag, line.str());
+ }
- virtual ~PrintfRecord();
+ /** Dump a block of data of length len */
+ void dump(Tick when, const std::string &name,
+ const void *d, int len, const std::string &flag);
- virtual void dump(std::ostream &);
- };
+ /** Log formatted message */
+ virtual void logMessage(Tick when, const std::string &name,
+ const std::string &flag, const std::string &message) = 0;
- class DataRecord : public Record
- {
- private:
- const std::string &name;
- uint8_t *data;
- int len;
+ /** 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;
- public:
- DataRecord(Tick cycle, const std::string &name,
- const void *_data, int _len);
- virtual ~DataRecord();
+ /** Set objects to ignore */
+ void setIgnore(ObjectMatch &ignore_) { ignore = ignore_; }
- virtual void dump(std::ostream &);
- };
+ /** Add objects to ignore */
+ void addIgnore(const ObjectMatch &ignore_) { ignore.add(ignore_); }
- class Log
- {
- private:
- int size; // number of records in log
- Record **buffer; // array of 'size' Record ptrs (circular buf)
- Record **nextRecPtr; // next slot to use in buffer
- Record **wrapRecPtr; // &buffer[size], for quick wrap check
+ virtual ~Logger() { }
+};
- public:
+/** Logging wrapper for ostreams with the format:
+ * <when>: <name>: <message-body> */
+class OstreamLogger : public Logger
+{
+ protected:
+ std::ostream &stream;
- Log();
- ~Log();
+ public:
+ OstreamLogger(std::ostream &stream_) : stream(stream_)
+ { }
- void init(int _size);
+ void logMessage(Tick when, const std::string &name,
+ const std::string &flag, const std::string &message) override;
- void append(Record *); // append trace record to log
- void dump(std::ostream &); // dump contents to stream
- };
+ std::ostream &getOstream() override { return stream; }
+};
- extern Log theLog;
+/** Get the current global debug logger. This takes ownership of the given
+ * logger which should be allocated using 'new' */
+Logger *getDebugLogger();
- extern ObjectMatch ignore;
+/** Get the ostream from the current global logger */
+std::ostream &output();
- inline void
- dprintf(const char *format, cp::ArgList &args, Tick cycle,
- const std::string &name)
- {
- if (name.empty() || !ignore.match(name))
- theLog.append(new Trace::PrintfRecord(format, args, cycle, name));
- }
+/** Delete the current global logger and assign a new one */
+void setDebugLogger(Logger *logger);
- inline void
- dataDump(Tick cycle, const std::string &name, const void *data, int len)
- {
- theLog.append(new Trace::DataRecord(cycle, name, data, len));
- }
+/** Enable/disable debug logging */
+void enable();
+void disable();
- extern const std::string DefaultName;
-};
+} // namespace Trace
// This silly little class allows us to wrap a string in a functor
// object so that we can give a name() that DPRINTF will like
const std::string &operator()() const { return str; }
};
-inline const std::string &name() { return Trace::DefaultName; }
-std::ostream &DebugOut();
+// 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();
-//
-// DPRINTF is a debugging trace facility that allows one to
-// selectively enable tracing statements. To use DPRINTF, there must
-// be a function or functor called name() that returns a const
-// std::string & in the current scope.
-//
-// If you desire that the automatic printing not occur, use DPRINTFR
-// (R for raw)
-//
+// Interface for things with names. (cf. SimObject but without other
+// functionality). This is useful when using DPRINTF
+class Named
+{
+ protected:
+ const std::string _name;
+
+ public:
+ Named(const std::string &name_) : _name(name_) { }
+
+ public:
+ const std::string &name() const { return _name; }
+};
+
+/**
+ * DPRINTF is a debugging trace facility that allows one to
+ * selectively enable tracing statements. To use DPRINTF, there must
+ * be a function or functor called name() that returns a const
+ * std::string & in the current scope.
+ *
+ * If you desire that the automatic printing not occur, use DPRINTFR
+ * (R for raw)
+ *
+ * \def DDUMP(x, data, count)
+ * \def DPRINTF(x, ...)
+ * \def DPRINTFS(x, s, ...)
+ * \def DPRINTFR(x, ...)
+ * \def DDUMPN(data, count)
+ * \def DPRINTFN(...)
+ * \def DPRINTFNR(...)
+ * \def DPRINTF_UNCONDITIONAL(x, ...)
+ *
+ * @ingroup api_trace
+ * @{
+ */
#if TRACING_ON
-#define DTRACE(x) (Trace::IsOn(Trace::x))
+#define DDUMP(x, data, count) do { \
+ using namespace Debug; \
+ if (M5_UNLIKELY(DTRACE(x))) \
+ Trace::getDebugLogger()->dump( \
+ curTick(), name(), data, count, #x); \
+} while (0)
-#define DCOUT(x) if (Trace::IsOn(Trace::x)) DebugOut()
+#define DPRINTF(x, ...) do { \
+ using namespace Debug; \
+ if (M5_UNLIKELY(DTRACE(x))) { \
+ Trace::getDebugLogger()->dprintf_flag( \
+ curTick(), name(), #x, __VA_ARGS__); \
+ } \
+} while (0)
-#define DDUMP(x, data, count) \
-do { \
- if (Trace::IsOn(Trace::x)) \
- Trace::dataDump(curTick, name(), data, count); \
+#define DPRINTFS(x, s, ...) do { \
+ using namespace Debug; \
+ if (M5_UNLIKELY(DTRACE(x))) { \
+ Trace::getDebugLogger()->dprintf_flag( \
+ curTick(), s->name(), #x, __VA_ARGS__); \
+ } \
} while (0)
-#define __dprintf(cycle, name, format, ...) \
- Trace::dprintf(format, (*(new cp::ArgList), __VA_ARGS__), cycle, name)
+#define DPRINTFR(x, ...) do { \
+ using namespace Debug; \
+ if (M5_UNLIKELY(DTRACE(x))) { \
+ Trace::getDebugLogger()->dprintf_flag( \
+ (Tick)-1, std::string(), #x, __VA_ARGS__); \
+ } \
+} while (0)
-#define DPRINTF(x, ...) \
-do { \
- if (Trace::IsOn(Trace::x)) \
- __dprintf(curTick, name(), __VA_ARGS__, cp::ArgListNull()); \
+#define DDUMPN(data, count) do { \
+ Trace::getDebugLogger()->dump(curTick(), name(), data, count); \
} while (0)
-#define DPRINTFR(x, ...) \
-do { \
- if (Trace::IsOn(Trace::x)) \
- __dprintf((Tick)-1, std::string(), __VA_ARGS__, cp::ArgListNull()); \
+#define DPRINTFN(...) do { \
+ Trace::getDebugLogger()->dprintf(curTick(), name(), __VA_ARGS__); \
} while (0)
-#define DPRINTFN(...) \
-do { \
- __dprintf(curTick, name(), __VA_ARGS__, cp::ArgListNull()); \
+#define DPRINTFNR(...) do { \
+ Trace::getDebugLogger()->dprintf((Tick)-1, std::string(), __VA_ARGS__); \
} while (0)
-#define DPRINTFNR(...) \
-do { \
- __dprintf((Tick)-1, string(), __VA_ARGS__, cp::ArgListNull()); \
+#define DPRINTF_UNCONDITIONAL(x, ...) do { \
+ Trace::getDebugLogger()->dprintf_flag( \
+ curTick(), name(), #x, __VA_ARGS__); \
} while (0)
#else // !TRACING_ON
-#define DTRACE(x) (false)
-#define DCOUT(x) if (0) DebugOut()
+#define DDUMP(x, data, count) do {} while (0)
#define DPRINTF(x, ...) do {} while (0)
+#define DPRINTFS(x, ...) do {} while (0)
#define DPRINTFR(...) do {} while (0)
+#define DDUMPN(data, count) do {} while (0)
#define DPRINTFN(...) do {} while (0)
#define DPRINTFNR(...) do {} while (0)
-#define DDUMP(x, data, count) do {} while (0)
+#define DPRINTF_UNCONDITIONAL(x, ...) do {} while (0)
+
+#endif // TRACING_ON
-#endif // TRACING_ON
+/** @} */ // end of api_trace
#endif // __BASE_TRACE_HH__
projects / gem5.git / blobdiff