src/base/trace.hh

   1 /*
   2  * Copyright (c) 2014 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Copyright (c) 2001-2006 The Regents of The University of Michigan
  15  * All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions are
  19  * met: redistributions of source code must retain the above copyright
  20  * notice, this list of conditions and the following disclaimer;
  21  * redistributions in binary form must reproduce the above copyright
  22  * notice, this list of conditions and the following disclaimer in the
  23  * documentation and/or other materials provided with the distribution;
  24  * neither the name of the copyright holders nor the names of its
  25  * contributors may be used to endorse or promote products derived from
  26  * this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39  *
  40  * Authors: Nathan Binkert
  41  *          Steve Reinhardt
  42  */
  43
  44 #ifndef __BASE_TRACE_HH__
  45 #define __BASE_TRACE_HH__
  46
  47 #include <string>
  48
  49 #include "base/cprintf.hh"
  50 #include "base/debug.hh"
  51 #include "base/match.hh"
  52 #include "base/types.hh"
  53 #include "sim/core.hh"
  54
  55 namespace Trace {
  56
  57 using Debug::SimpleFlag;
  58 using Debug::CompoundFlag;
  59
  60 std::ostream &output();
  61 void setOutput(const std::string &filename);
  62
  63 extern bool enabled;
  64 bool changeFlag(const char *str, bool value);
  65 void dumpStatus();
  66
  67 extern ObjectMatch ignore;
  68 extern const std::string DefaultName;
  69
  70 bool __dprintf_prologue(Tick when, const std::string &name);
  71
  72 template<typename ...Args> void
  73 dprintf(Tick when, const std::string &name, const char *format,
  74         const Args &...args)
  75 {
  76     if (!__dprintf_prologue(when, name))
  77         return;
  78
  79     std::ostream &os(output());
  80     ccprintf(os, format, args...);
  81     os.flush();
  82 }
  83
  84 void dump(Tick when, const std::string &name, const void *data, int len);
  85
  86 } // namespace Trace
  87
  88 // This silly little class allows us to wrap a string in a functor
  89 // object so that we can give a name() that DPRINTF will like
  90 struct StringWrap
  91 {
  92     std::string str;
  93     StringWrap(const std::string &s) : str(s) {}
  94     const std::string &operator()() const { return str; }
  95 };
  96
  97 inline const std::string &name() { return Trace::DefaultName; }
  98
  99 // Interface for things with names. (cf. SimObject but without other
 100 // functionality).  This is useful when using DPRINTF
 101 class Named
 102 {
 103   protected:
 104     const std::string _name;
 105
 106   public:
 107     Named(const std::string &name_) : _name(name_) { }
 108
 109   public:
 110     const std::string &name() const { return _name; }
 111 };
 112
 113 //
 114 // DPRINTF is a debugging trace facility that allows one to
 115 // selectively enable tracing statements.  To use DPRINTF, there must
 116 // be a function or functor called name() that returns a const
 117 // std::string & in the current scope.
 118 //
 119 // If you desire that the automatic printing not occur, use DPRINTFR
 120 // (R for raw)
 121 //
 122
 123 #if TRACING_ON
 124
 125 #define DTRACE(x) ((Debug::x) && Trace::enabled)
 126
 127 #define DDUMP(x, data, count) do {                              \
 128     using namespace Debug;                                      \
 129     if (DTRACE(x))                                              \
 130         Trace::dump(curTick(), name(), data, count);              \
 131 } while (0)
 132
 133 #define DPRINTF(x, ...) do {                                    \
 134     using namespace Debug;                                      \
 135     if (DTRACE(x))                                              \
 136         Trace::dprintf(curTick(), name(), __VA_ARGS__);           \
 137 } while (0)
 138
 139 #define DPRINTFS(x, s, ...) do {                                \
 140     using namespace Debug;                                      \
 141     if (DTRACE(x))                                              \
 142         Trace::dprintf(curTick(), s->name(), __VA_ARGS__);      \
 143 } while (0)
 144
 145 #define DPRINTFR(x, ...) do {                                   \
 146     using namespace Debug;                                      \
 147     if (DTRACE(x))                                              \
 148         Trace::dprintf((Tick)-1, std::string(), __VA_ARGS__);   \
 149 } while (0)
 150
 151 #define DDUMPN(data, count) do {                                \
 152     Trace::dump(curTick(), name(), data, count);                  \
 153 } while (0)
 154
 155 #define DPRINTFN(...) do {                                      \
 156     Trace::dprintf(curTick(), name(), __VA_ARGS__);               \
 157 } while (0)
 158
 159 #define DPRINTFNR(...) do {                                     \
 160     Trace::dprintf((Tick)-1, string(), __VA_ARGS__);            \
 161 } while (0)
 162
 163 #else // !TRACING_ON
 164
 165 #define DTRACE(x) (false)
 166 #define DDUMP(x, data, count) do {} while (0)
 167 #define DPRINTF(x, ...) do {} while (0)
 168 #define DPRINTFS(x, ...) do {} while (0)
 169 #define DPRINTFR(...) do {} while (0)
 170 #define DDUMPN(data, count) do {} while (0)
 171 #define DPRINTFN(...) do {} while (0)
 172 #define DPRINTFNR(...) do {} while (0)
 173
 174 #endif  // TRACING_ON
 175
 176 #endif // __BASE_TRACE_HH__