src/cpu/checker/thread_context.hh

   1 /*
   2  * Copyright (c) 2006 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  * Authors: Kevin Lim
  29  */
  30
  31 #ifndef __CPU_CHECKER_THREAD_CONTEXT_HH__
  32 #define __CPU_CHECKER_THREAD_CONTEXT_HH__
  33
  34 #include "arch/types.hh"
  35 #include "config/the_isa.hh"
  36 #include "cpu/checker/cpu.hh"
  37 #include "cpu/simple_thread.hh"
  38 #include "cpu/thread_context.hh"
  39
  40 class EndQuiesceEvent;
  41 namespace TheISA {
  42     namespace Kernel {
  43         class Statistics;
  44     };
  45 };
  46
  47 /**
  48  * Derived ThreadContext class for use with the Checker.  The template
  49  * parameter is the ThreadContext class used by the specific CPU being
  50  * verified.  This CheckerThreadContext is then used by the main CPU
  51  * in place of its usual ThreadContext class.  It handles updating the
  52  * checker's state any time state is updated externally through the
  53  * ThreadContext.
  54  */
  55 template <class TC>
  56 class CheckerThreadContext : public ThreadContext
  57 {
  58   public:
  59     CheckerThreadContext(TC *actual_tc,
  60                          CheckerCPU *checker_cpu)
  61         : actualTC(actual_tc), checkerTC(checker_cpu->thread),
  62           checkerCPU(checker_cpu)
  63     { }
  64
  65   private:
  66     /** The main CPU's ThreadContext, or class that implements the
  67      * ThreadContext interface. */
  68     TC *actualTC;
  69     /** The checker's own SimpleThread. Will be updated any time
  70      * anything uses this ThreadContext to externally update a
  71      * thread's state. */
  72     SimpleThread *checkerTC;
  73     /** Pointer to the checker CPU. */
  74     CheckerCPU *checkerCPU;
  75
  76   public:
  77
  78     BaseCPU *getCpuPtr() { return actualTC->getCpuPtr(); }
  79
  80     void setCpuId(int id)
  81     {
  82         actualTC->setCpuId(id);
  83         checkerTC->setCpuId(id);
  84     }
  85
  86     int cpuId() { return actualTC->cpuId(); }
  87
  88     TheISA::TLB *getITBPtr() { return actualTC->getITBPtr(); }
  89
  90     TheISA::TLB *getDTBPtr() { return actualTC->getDTBPtr(); }
  91
  92 #if FULL_SYSTEM
  93     System *getSystemPtr() { return actualTC->getSystemPtr(); }
  94
  95     PhysicalMemory *getPhysMemPtr() { return actualTC->getPhysMemPtr(); }
  96
  97     TheISA::Kernel::Statistics *getKernelStats()
  98     { return actualTC->getKernelStats(); }
  99
 100     FunctionalPort *getPhysPort() { return actualTC->getPhysPort(); }
 101
 102     VirtualPort *getVirtPort()
 103     { return actualTC->getVirtPort(); }
 104 #else
 105     TranslatingPort *getMemPort() { return actualTC->getMemPort(); }
 106
 107     Process *getProcessPtr() { return actualTC->getProcessPtr(); }
 108 #endif
 109
 110     Status status() const { return actualTC->status(); }
 111
 112     void setStatus(Status new_status)
 113     {
 114         actualTC->setStatus(new_status);
 115         checkerTC->setStatus(new_status);
 116     }
 117
 118     /// Set the status to Active.  Optional delay indicates number of
 119     /// cycles to wait before beginning execution.
 120     void activate(int delay = 1) { actualTC->activate(delay); }
 121
 122     /// Set the status to Suspended.
 123     void suspend() { actualTC->suspend(); }
 124
 125     /// Set the status to Halted.
 126     void halt() { actualTC->halt(); }
 127
 128 #if FULL_SYSTEM
 129     void dumpFuncProfile() { actualTC->dumpFuncProfile(); }
 130 #endif
 131
 132     void takeOverFrom(ThreadContext *oldContext)
 133     {
 134         actualTC->takeOverFrom(oldContext);
 135         checkerTC->copyState(oldContext);
 136     }
 137
 138     void regStats(const std::string &name) { actualTC->regStats(name); }
 139
 140     void serialize(std::ostream &os) { actualTC->serialize(os); }
 141     void unserialize(Checkpoint *cp, const std::string &section)
 142     { actualTC->unserialize(cp, section); }
 143
 144 #if FULL_SYSTEM
 145     EndQuiesceEvent *getQuiesceEvent() { return actualTC->getQuiesceEvent(); }
 146
 147     Tick readLastActivate() { return actualTC->readLastActivate(); }
 148     Tick readLastSuspend() { return actualTC->readLastSuspend(); }
 149
 150     void profileClear() { return actualTC->profileClear(); }
 151     void profileSample() { return actualTC->profileSample(); }
 152 #endif
 153
 154     int threadId() { return actualTC->threadId(); }
 155
 156     // @todo: Do I need this?
 157     MachInst getInst() { return actualTC->getInst(); }
 158
 159     // @todo: Do I need this?
 160     void copyArchRegs(ThreadContext *tc)
 161     {
 162         actualTC->copyArchRegs(tc);
 163         checkerTC->copyArchRegs(tc);
 164     }
 165
 166     void clearArchRegs()
 167     {
 168         actualTC->clearArchRegs();
 169         checkerTC->clearArchRegs();
 170     }
 171
 172     //
 173     // New accessors for new decoder.
 174     //
 175     uint64_t readIntReg(int reg_idx)
 176     { return actualTC->readIntReg(reg_idx); }
 177
 178     FloatReg readFloatReg(int reg_idx)
 179     { return actualTC->readFloatReg(reg_idx); }
 180
 181     FloatRegBits readFloatRegBits(int reg_idx)
 182     { return actualTC->readFloatRegBits(reg_idx); }
 183
 184     void setIntReg(int reg_idx, uint64_t val)
 185     {
 186         actualTC->setIntReg(reg_idx, val);
 187         checkerTC->setIntReg(reg_idx, val);
 188     }
 189
 190     void setFloatReg(int reg_idx, FloatReg val)
 191     {
 192         actualTC->setFloatReg(reg_idx, val);
 193         checkerTC->setFloatReg(reg_idx, val);
 194     }
 195
 196     void setFloatRegBits(int reg_idx, FloatRegBits val)
 197     {
 198         actualTC->setFloatRegBits(reg_idx, val);
 199         checkerTC->setFloatRegBits(reg_idx, val);
 200     }
 201
 202     uint64_t readPC() { return actualTC->readPC(); }
 203
 204     void setPC(uint64_t val)
 205     {
 206         actualTC->setPC(val);
 207         checkerTC->setPC(val);
 208         checkerCPU->recordPCChange(val);
 209     }
 210
 211     uint64_t readNextPC() { return actualTC->readNextPC(); }
 212
 213     void setNextPC(uint64_t val)
 214     {
 215         actualTC->setNextPC(val);
 216         checkerTC->setNextPC(val);
 217         checkerCPU->recordNextPCChange(val);
 218     }
 219
 220     uint64_t readNextNPC() { return actualTC->readNextNPC(); }
 221
 222     void setNextNPC(uint64_t val)
 223     {
 224         actualTC->setNextNPC(val);
 225         checkerTC->setNextNPC(val);
 226         checkerCPU->recordNextPCChange(val);
 227     }
 228
 229     MiscReg readMiscRegNoEffect(int misc_reg)
 230     { return actualTC->readMiscRegNoEffect(misc_reg); }
 231
 232     MiscReg readMiscReg(int misc_reg)
 233     { return actualTC->readMiscReg(misc_reg); }
 234
 235     void setMiscRegNoEffect(int misc_reg, const MiscReg &val)
 236     {
 237         checkerTC->setMiscRegNoEffect(misc_reg, val);
 238         actualTC->setMiscRegNoEffect(misc_reg, val);
 239     }
 240
 241     void setMiscReg(int misc_reg, const MiscReg &val)
 242     {
 243         checkerTC->setMiscReg(misc_reg, val);
 244         actualTC->setMiscReg(misc_reg, val);
 245     }
 246
 247     unsigned readStCondFailures()
 248     { return actualTC->readStCondFailures(); }
 249
 250     void setStCondFailures(unsigned sc_failures)
 251     {
 252         checkerTC->setStCondFailures(sc_failures);
 253         actualTC->setStCondFailures(sc_failures);
 254     }
 255
 256     // @todo: Fix this!
 257     bool misspeculating() { return actualTC->misspeculating(); }
 258
 259 #if !FULL_SYSTEM
 260     Counter readFuncExeInst() { return actualTC->readFuncExeInst(); }
 261 #endif
 262 };
 263
 264 #endif // __CPU_CHECKER_EXEC_CONTEXT_HH__