base/trace.cc

   1 /*
   2  * Copyright (c) 2003 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <ctype.h>
  30 #include <fstream>
  31 #include <iostream>
  32 #include <list>
  33 #include <string>
  34 #include <vector>
  35
  36 #include "base/misc.hh"
  37 #include "base/trace.hh"
  38 #include "base/str.hh"
  39
  40 using namespace std;
  41
  42 namespace Trace {
  43 const string DefaultName("global");
  44 FlagVec flags(NumFlags, false);
  45
  46 //
  47 // This variable holds the output stream for debug information.  Other
  48 // than setting up/redirecting this stream, do *NOT* reference this
  49 // directly; use DebugOut() (see below) to access this stream for
  50 // output.
  51 //
  52 ostream *dprintf_stream = &cerr;
  53
  54 int dprintf_ignore_size;
  55 vector<string> dprintf_ignore;
  56 vector<vector<string> > ignore_tokens;
  57 vector<int> ignore_size;
  58
  59 bool
  60 dprintf_ignore_name(const string &name)
  61 {
  62     vector<string> name_tokens;
  63     tokenize(name_tokens, name, '.');
  64     int ntsize = name_tokens.size();
  65
  66     for (int i = 0; i < dprintf_ignore_size; ++i) {
  67         bool match = true;
  68         int jstop = ignore_size[i];
  69         for (int j = 0; j < jstop; ++j) {
  70             if (j >= ntsize)
  71                 break;
  72
  73             const string &ignore = ignore_tokens[i][j];
  74             if (ignore != "*" && ignore != name_tokens[j]) {
  75                 match = false;
  76                 break;
  77             }
  78         }
  79
  80         if (match == true)
  81             return true;
  82     }
  83
  84     return false;
  85 }
  86
  87
  88 Log theLog;
  89
  90 Log::Log()
  91 {
  92     size = 0;
  93     buffer = NULL;
  94 }
  95
  96
  97 void
  98 Log::init(int _size)
  99 {
 100     if (buffer != NULL) {
 101         fatal("Trace::Log::init called twice!");
 102     }
 103
 104     size = _size;
 105
 106     buffer = new (Record *)[size];
 107
 108     for (int i = 0; i < size; ++i) {
 109         buffer[i] = NULL;
 110     }
 111
 112     nextRecPtr = &buffer[0];
 113     wrapRecPtr = &buffer[size];
 114 }
 115
 116
 117 Log::~Log()
 118 {
 119     for (int i = 0; i < size; ++i) {
 120         delete buffer[i];
 121     }
 122
 123     delete [] buffer;
 124 }
 125
 126
 127 void
 128 Log::append(Record *rec)
 129 {
 130     // dump record to output stream if there's one open
 131     if (dprintf_stream != NULL) {
 132         rec->dump(*dprintf_stream);
 133     }
 134
 135     // no buffering: justget rid of it now
 136     if (buffer == NULL) {
 137         delete rec;
 138         return;
 139     }
 140
 141     Record *oldRec = *nextRecPtr;
 142
 143     if (oldRec != NULL) {
 144         // log has wrapped: overwrite
 145         delete oldRec;
 146     }
 147
 148     *nextRecPtr = rec;
 149
 150     if (++nextRecPtr == wrapRecPtr) {
 151         nextRecPtr = &buffer[0];
 152     }
 153 }
 154
 155
 156 void
 157 Log::dump(ostream &os)
 158 {
 159     if (buffer == NULL) {
 160         return;
 161     }
 162
 163     Record **bufPtr = nextRecPtr;
 164
 165     if (*bufPtr == NULL) {
 166         // next record slot is empty: log must not be full yet.
 167         // start dumping from beginning of buffer
 168         bufPtr = buffer;
 169     }
 170
 171     do {
 172         Record *rec = *bufPtr;
 173
 174         rec->dump(os);
 175
 176         if (++bufPtr == wrapRecPtr) {
 177             bufPtr = &buffer[0];
 178         }
 179     } while (bufPtr != nextRecPtr);
 180 }
 181
 182 PrintfRecord::~PrintfRecord()
 183 {
 184     delete &args;
 185 }
 186
 187
 188 void
 189 PrintfRecord::dump(ostream &os)
 190 {
 191     string fmt = "";
 192
 193     if (!name.empty()) {
 194         fmt = "%s: " + fmt;
 195         args.prepend(name);
 196     }
 197
 198     if (cycle != (Tick)-1) {
 199         fmt = "%7d: " + fmt;
 200         args.prepend(cycle);
 201     }
 202
 203     fmt += format;
 204
 205     args.dump(os, fmt);
 206     os.flush();
 207 }
 208
 209
 210
 211 RawDataRecord::RawDataRecord(Tick _cycle,
 212                                     const uint8_t *_data, int _len)
 213     : Record(_cycle), len(_len)
 214 {
 215     data = new uint8_t[len];
 216     memcpy(data, _data, len);
 217 }
 218
 219
 220 RawDataRecord::~RawDataRecord()
 221 {
 222     delete [] data;
 223 }
 224
 225
 226 void
 227 RawDataRecord::dump(ostream &os)
 228 {
 229     int c, i, j;
 230
 231     for (i = 0; i < len; i += 16) {
 232         ccprintf(os, "%08x  ", i);
 233         c = len - i;
 234         if (c > 16) c = 16;
 235
 236         for (j = 0; j < c; j++) {
 237             ccprintf(os, "%02x ", data[i + j] & 0xff);
 238             if ((j & 0xf) == 7 && j > 0)
 239                 ccprintf(os, " ");
 240         }
 241
 242         for (; j < 16; j++)
 243             ccprintf(os, "   ");
 244         ccprintf(os, "  ");
 245
 246         for (j = 0; j < c; j++) {
 247             int ch = data[i + j] & 0x7f;
 248             ccprintf(os,
 249                      "%c", (char)(isprint(ch) ? ch : ' '));
 250         }
 251
 252         ccprintf(os, "\n");
 253
 254         if (c < 16)
 255             break;
 256     }
 257 }
 258 } // namespace Trace
 259
 260 //
 261 // Returns the current output stream for debug information.  As a
 262 // wrapper around Trace::dprintf_stream, this handles cases where debug
 263 // information is generated in the process of parsing .ini options,
 264 // before we process the option that sets up the debug output stream
 265 // itself.
 266 //
 267 std::ostream &
 268 DebugOut()
 269 {
 270     return *Trace::dprintf_stream;
 271 }
 272
 273 /////////////////////////////////////////////
 274 //
 275 // C-linkage functions for invoking from gdb
 276 //
 277 /////////////////////////////////////////////
 278
 279 //
 280 // Dump trace buffer to specified file (cout if NULL)
 281 //
 282 extern "C"
 283 void
 284 dumpTrace(const char *filename)
 285 {
 286     if (filename != NULL) {
 287         ofstream out(filename);
 288         Trace::theLog.dump(out);
 289         out.close();
 290     }
 291     else {
 292         Trace::theLog.dump(cout);
 293     }
 294 }
 295
 296
 297 //
 298 // Turn on/off trace output to cerr.  Typically used when trace output
 299 // is only going to circular buffer, but you want to see what's being
 300 // sent there as you step through some code in gdb.  This uses the
 301 // same facility as the "trace to file" feature, and will print error
 302 // messages rather than clobbering an existing ostream pointer.
 303 //
 304 extern "C"
 305 void
 306 echoTrace(bool on)
 307 {
 308     if (on) {
 309         if (Trace::dprintf_stream != NULL) {
 310             cerr << "Already echoing trace to a file... go do a 'tail -f'"
 311                  << " on that file instead." << endl;
 312         } else {
 313             Trace::dprintf_stream = &cerr;
 314         }
 315     } else {
 316         if (Trace::dprintf_stream != &cerr) {
 317             cerr << "Not echoing trace to cerr." << endl;
 318         } else {
 319             Trace::dprintf_stream = NULL;
 320         }
 321     }
 322 }