src/cpu/inst_pb_trace.cc

   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  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include "cpu/inst_pb_trace.hh"
  39
  40 #include "base/callback.hh"
  41 #include "base/output.hh"
  42 #include "config/the_isa.hh"
  43 #include "cpu/static_inst.hh"
  44 #include "cpu/thread_context.hh"
  45 #include "debug/ExecEnable.hh"
  46 #include "params/InstPBTrace.hh"
  47 #include "proto/inst.pb.h"
  48 #include "sim/core.hh"
  49
  50 namespace Trace {
  51
  52 ProtoOutputStream *InstPBTrace::traceStream;
  53
  54 void
  55 InstPBTraceRecord::dump()
  56 {
  57     // We're trying to build an instruction trace so we just want macro-ops and
  58     // instructions that aren't macro-oped
  59     if ((macroStaticInst && staticInst->isFirstMicroop()) ||
  60             !staticInst->isMicroop()) {
  61         tracer.traceInst(thread, staticInst, pc);
  62     }
  63
  64     // If this instruction accessed memory lets record it
  65     if (getMemValid())
  66         tracer.traceMem(staticInst, getAddr(), getSize(), getFlags());
  67 }
  68
  69 InstPBTrace::InstPBTrace(const InstPBTraceParams *p)
  70     : InstTracer(p), buf(nullptr), bufSize(0), curMsg(nullptr)
  71 {
  72     // Create our output file
  73     createTraceFile(p->file_name);
  74 }
  75
  76 void
  77 InstPBTrace::createTraceFile(std::string filename)
  78 {
  79     // Since there is only one output file for all tracers check if it exists
  80     if (traceStream)
  81         return;
  82
  83     traceStream = new ProtoOutputStream(simout.resolve(filename));
  84
  85     // Output the header
  86     ProtoMessage::InstHeader header_msg;
  87     header_msg.set_obj_id("gem5 generated instruction trace");
  88     header_msg.set_ver(0);
  89     header_msg.set_tick_freq(SimClock::Frequency);
  90     header_msg.set_has_mem(true);
  91     traceStream->write(header_msg);
  92
  93     // get a callback when we exit so we can close the file
  94     registerExitCallback([this]() { closeStreams(); });
  95 }
  96
  97 void
  98 InstPBTrace::closeStreams()
  99 {
 100     if (curMsg) {
 101         traceStream->write(*curMsg);
 102         delete curMsg;
 103         curMsg = NULL;
 104     }
 105
 106     if (!traceStream)
 107         return;
 108
 109     delete traceStream;
 110     traceStream = NULL;
 111 }
 112
 113 InstPBTrace::~InstPBTrace()
 114 {
 115     closeStreams();
 116 }
 117
 118 InstPBTraceRecord*
 119 InstPBTrace::getInstRecord(Tick when, ThreadContext *tc, const StaticInstPtr si,
 120                            TheISA::PCState pc, const StaticInstPtr mi)
 121 {
 122     // Only record the trace if Exec debugging is enabled
 123     if (!Debug::ExecEnable)
 124         return NULL;
 125
 126     return new InstPBTraceRecord(*this, when, tc, si, pc, mi);
 127
 128 }
 129
 130 void
 131 InstPBTrace::traceInst(ThreadContext *tc, StaticInstPtr si, TheISA::PCState pc)
 132 {
 133     if (curMsg) {
 134         /// @todo if we are running multi-threaded I assume we'd need a lock here
 135         traceStream->write(*curMsg);
 136         delete curMsg;
 137         curMsg = NULL;
 138     }
 139
 140     size_t instSize = si->asBytes(buf.get(), bufSize);
 141     if (instSize > bufSize) {
 142         bufSize = instSize;
 143         buf.reset(new uint8_t[bufSize]);
 144         instSize = si->asBytes(buf.get(), bufSize);
 145     }
 146
 147     // Create a new instruction message and fill out the fields
 148     curMsg = new ProtoMessage::Inst;
 149     curMsg->set_pc(pc.pc());
 150     if (instSize == sizeof(uint32_t)) {
 151         curMsg->set_inst(letoh(*reinterpret_cast<uint32_t *>(buf.get())));
 152     } else if (instSize) {
 153         curMsg->set_inst_bytes(
 154             std::string(reinterpret_cast<const char *>(buf.get()), bufSize));
 155     }
 156     curMsg->set_cpuid(tc->cpuId());
 157     curMsg->set_tick(curTick());
 158     curMsg->set_type(static_cast<ProtoMessage::Inst_InstType>(si->opClass()));
 159 }
 160
 161 void
 162 InstPBTrace::traceMem(StaticInstPtr si, Addr a, Addr s, unsigned f)
 163 {
 164     panic_if(!curMsg, "Memory access w/o msg?!");
 165
 166     // We do a poor job identifying macro-ops that are load/stores
 167     curMsg->set_type(static_cast<ProtoMessage::Inst_InstType>(si->opClass()));
 168
 169     ProtoMessage::Inst::MemAccess *mem_msg = curMsg->add_mem_access();
 170     mem_msg->set_addr(a);
 171     mem_msg->set_size(s);
 172     mem_msg->set_mem_flags(f);
 173
 174 }
 175
 176 } // namespace Trace
 177
 178
 179 Trace::InstPBTrace*
 180 InstPBTraceParams::create()
 181 {
 182     return new Trace::InstPBTrace(this);
 183 }
 184