Steps towards setting up the infrastructure to allow the new CPU model to work in full system mode.

The major change is renaming the old ExecContext to CPUExecContext, and creating two new classes, ExecContext (an abstract class), and ProxyExecContext (a templated class that derives from ExecContext).

Code outside of the CPU continues to use ExecContext as normal (other than not being able to access variables within the XC).  The CPU uses the CPUExecContext, or however else it stores its own state.  It then creates a ProxyExecContext, templated on the class used to hold its state.  This proxy is passed to any code outside of the CPU that needs to access the XC.  This allows code outside of the CPU to use the ExecContext interface to access any state needed, without knowledge of how that state is laid out.

Note that these changes will not compile without the accompanying revision to automatically rename the shadow registers.

SConscript:
    Include new file, cpu_exec_context.cc.
arch/alpha/alpha_linux_process.cc:
arch/alpha/alpha_memory.cc:
arch/alpha/alpha_tru64_process.cc:
arch/alpha/arguments.cc:
arch/alpha/isa/decoder.isa:
arch/alpha/stacktrace.cc:
arch/alpha/vtophys.cc:
base/remote_gdb.cc:
cpu/intr_control.cc:
    Avoid directly accessing objects within the XC.
arch/alpha/ev5.cc:
    Avoid directly accessing objects within the XC.

    KernelStats have been moved to the BaseCPU instead of the XC.
arch/alpha/isa_traits.hh:
    Remove clearIprs().  It wasn't used very often and it did not work well with the proxy ExecContext.
cpu/base.cc:
    Place kernel stats within the BaseCPU instead of the ExecContext.

    For now comment out the profiling code sampling until its exact location is decided upon.
cpu/base.hh:
    Kernel stats are now in the BaseCPU instead of the ExecContext.
cpu/base_dyn_inst.cc:
cpu/base_dyn_inst.hh:
cpu/memtest/memtest.cc:
cpu/memtest/memtest.hh:
    Changes to support rename of old ExecContext to CPUExecContext.  See changeset for more details.
cpu/exetrace.cc:
    Remove unneeded include of exec_context.hh.
cpu/intr_control.hh:
cpu/o3/alpha_cpu_builder.cc:
    Remove unneeded include of exec_context.hh
cpu/o3/alpha_cpu.hh:
cpu/o3/alpha_cpu_impl.hh:
cpu/o3/cpu.cc:
cpu/o3/cpu.hh:
cpu/simple/cpu.cc:
cpu/simple/cpu.hh:
    Changes to support rename of old ExecContext to CPUExecContext.  See changeset for more details.

    Also avoid accessing anything directly from the XC.
cpu/pc_event.cc:
    Avoid accessing objects directly from the XC.
dev/tsunami_cchip.cc:
    Avoid accessing objects directly within the XC>
kern/freebsd/freebsd_system.cc:
kern/linux/linux_system.cc:
kern/linux/linux_threadinfo.hh:
kern/tru64/dump_mbuf.cc:
kern/tru64/tru64.hh:
kern/tru64/tru64_events.cc:
sim/syscall_emul.cc:
sim/syscall_emul.hh:
    Avoid accessing objects directly within the XC.
kern/kernel_stats.cc:
kern/kernel_stats.hh:
    Kernel stats no longer exist within the XC.
kern/system_events.cc:
    Avoid accessing objects directly within the XC.  Also kernel stats are now in the BaseCPU.
sim/process.cc:
sim/process.hh:
    Avoid accessing regs directly within an ExecContext.  Instead use a CPUExecContext to initialize the registers and copy them over.
cpu/cpu_exec_context.cc:
    Rename old ExecContext to CPUExecContext.  This is used by the old CPU models to store any necessary architectural state.  Also include the ProxyExecContext, which is used to access the CPUExecContext's state in code outside of the CPU.
cpu/cpu_exec_context.hh:
    Rename old ExecContext to CPUExecContext.  This is used by the old CPU models to store any necessary architectural state.  Also include the ProxyExecContext, which is used to access the CPUExecContext's state in code outside of the CPU.

    Remove kernel stats from the ExecContext.
sim/pseudo_inst.cc:
    Kernel stats now live within the CPU.

    Avoid accessing objects directly within the XC.

--HG--
rename : cpu/exec_context.cc => cpu/cpu_exec_context.cc
rename : cpu/exec_context.hh => cpu/cpu_exec_context.hh
extra : convert_revision : a75393a8945c80cca225b5e9d9c22a16609efb85

9 files changed, 86 insertions, 86 deletions

diff --git a/kern/freebsd/freebsd_system.cc b/kern/freebsd/freebsd_system.cc
index cead8caaf..3db70a368 100644
--- a/kern/freebsd/freebsd_system.cc
+++ b/kern/freebsd/freebsd_system.cc
@@ -33,13 +33,13 @@
  *
  */
 
+#include "arch/isa_traits.hh"
 #include "base/loader/symtab.hh"
 #include "cpu/exec_context.hh"
 #include "kern/freebsd/freebsd_system.hh"
 #include "mem/functional/memory_control.hh"
 #include "mem/functional/physical.hh"
 #include "sim/builder.hh"
-#include "arch/isa_traits.hh"
 #include "sim/byteswap.hh"
 #include "targetarch/vtophys.hh"
 
@@ -76,8 +76,8 @@ FreebsdSystem::doCalibrateClocks(ExecContext *xc)
     Addr ppc_paddr = 0;
     Addr timer_paddr = 0;
 
-    ppc_vaddr = (Addr)xc->regs.intRegFile[ArgumentReg1];
-    timer_vaddr = (Addr)xc->regs.intRegFile[ArgumentReg2];
+    ppc_vaddr = (Addr)xc->readIntReg(ArgumentReg1);
+    timer_vaddr = (Addr)xc->readIntReg(ArgumentReg2);
 
     ppc_paddr = vtophys(physmem, ppc_vaddr);
     timer_paddr = vtophys(physmem, timer_vaddr);
@@ -94,7 +94,7 @@ void
 FreebsdSystem::SkipCalibrateClocksEvent::process(ExecContext *xc)
 {
     SkipFuncEvent::process(xc);
-    ((FreebsdSystem *)xc->system)->doCalibrateClocks(xc);
+    ((FreebsdSystem *)xc->getSystemPtr())->doCalibrateClocks(xc);
 }
 
 
diff --git a/kern/kernel_stats.cc b/kern/kernel_stats.cc
index 3beeaa14a..ddf1058e6 100644
--- a/kern/kernel_stats.cc
+++ b/kern/kernel_stats.cc
@@ -43,11 +43,11 @@ namespace Kernel {
 
 const char *modestr[] = { "kernel", "user", "idle", "interrupt" };
 
-Statistics::Statistics(ExecContext *context)
-    : xc(context), idleProcess((Addr)-1), themode(kernel), lastModeTick(0),
+Statistics::Statistics(System *system)
+    : idleProcess((Addr)-1), themode(kernel), lastModeTick(0),
       iplLast(0), iplLastTick(0)
 {
-    bin_int = xc->system->params->bin_int;
+    bin_int = system->params->bin_int;
 }
 
 void
@@ -193,16 +193,16 @@ Statistics::regStats(const string &_name)
 }
 
 void
-Statistics::setIdleProcess(Addr idlepcbb)
+Statistics::setIdleProcess(Addr idlepcbb, ExecContext *xc)
 {
     assert(themode == kernel || themode == interrupt);
     idleProcess = idlepcbb;
     themode = idle;
-    changeMode(themode);
+    changeMode(themode, xc);
 }
 
 void
-Statistics::changeMode(cpu_mode newmode)
+Statistics::changeMode(cpu_mode newmode, ExecContext *xc)
 {
     _mode[newmode]++;
 
@@ -215,7 +215,7 @@ Statistics::changeMode(cpu_mode newmode)
     _modeGood[newmode]++;
     _modeTicks[themode] += curTick - lastModeTick;
 
-    xc->system->kernelBinning->changeMode(newmode);
+    xc->getSystemPtr()->kernelBinning->changeMode(newmode);
 
     lastModeTick = curTick;
     themode = newmode;
@@ -238,7 +238,7 @@ Statistics::swpipl(int ipl)
 }
 
 void
-Statistics::mode(cpu_mode newmode)
+Statistics::mode(cpu_mode newmode, ExecContext *xc)
 {
     Addr pcbb = xc->readMiscReg(AlphaISA::IPR_PALtemp23);
 
@@ -249,20 +249,20 @@ Statistics::mode(cpu_mode newmode)
     if (bin_int == false && newmode == interrupt)
         newmode = kernel;
 
-    changeMode(newmode);
+    changeMode(newmode, xc);
 }
 
 void
-Statistics::context(Addr oldpcbb, Addr newpcbb)
+Statistics::context(Addr oldpcbb, Addr newpcbb, ExecContext *xc)
 {
     assert(themode != user);
 
     _swap_context++;
-    changeMode(newpcbb == idleProcess ? idle : kernel);
+    changeMode(newpcbb == idleProcess ? idle : kernel, xc);
 }
 
 void
-Statistics::callpal(int code)
+Statistics::callpal(int code, ExecContext *xc)
 {
     if (!PAL::name(code))
         return;
@@ -271,7 +271,7 @@ Statistics::callpal(int code)
 
     switch (code) {
       case PAL::callsys: {
-          int number = xc->regs.intRegFile[0];
+          int number = xc->readIntReg(0);
           if (SystemCalls<Tru64>::validSyscallNumber(number)) {
               int cvtnum = SystemCalls<Tru64>::convert(number);
               _syscall[cvtnum]++;
@@ -279,8 +279,8 @@ Statistics::callpal(int code)
       } break;
 
       case PAL::swpctx:
-        if (xc->system->kernelBinning)
-            xc->system->kernelBinning->palSwapContext(xc);
+        if (xc->getSystemPtr()->kernelBinning)
+            xc->getSystemPtr()->kernelBinning->palSwapContext(xc);
         break;
     }
 }
diff --git a/kern/kernel_stats.hh b/kern/kernel_stats.hh
index 02d78e4d9..6689dad01 100644
--- a/kern/kernel_stats.hh
+++ b/kern/kernel_stats.hh
@@ -128,14 +128,13 @@ class Statistics : public Serializable
 
   private:
     std::string myname;
-    ExecContext *xc;
 
     Addr idleProcess;
     cpu_mode themode;
     Tick lastModeTick;
     bool bin_int;
 
-    void changeMode(cpu_mode newmode);
+    void changeMode(cpu_mode newmode, ExecContext *xc);
 
   private:
     Stats::Scalar<> _arm;
@@ -165,7 +164,7 @@ class Statistics : public Serializable
     Tick iplLastTick;
 
   public:
-    Statistics(ExecContext *context);
+    Statistics(System *system);
 
     const std::string name() const { return myname; }
     void regStats(const std::string &name);
@@ -184,11 +183,11 @@ class Statistics : public Serializable
             else _faults[fault->id]++;
     }// FIXME: When there are no generic system fault objects, this will go back to _faults[fault]++; }
     void swpipl(int ipl);
-    void mode(cpu_mode newmode);
-    void context(Addr oldpcbb, Addr newpcbb);
-    void callpal(int code);
+    void mode(cpu_mode newmode, ExecContext *xc);
+    void context(Addr oldpcbb, Addr newpcbb, ExecContext *xc);
+    void callpal(int code, ExecContext *xc);
 
-    void setIdleProcess(Addr idle);
+    void setIdleProcess(Addr idle, ExecContext *xc);
 
   public:
     virtual void serialize(std::ostream &os);
diff --git a/kern/linux/linux_system.cc b/kern/linux/linux_system.cc
index c5a9e184a..a0da732f0 100644
--- a/kern/linux/linux_system.cc
+++ b/kern/linux/linux_system.cc
@@ -192,7 +192,7 @@ LinuxSystem::setDelayLoop(ExecContext *xc)
         uint8_t *loops_per_jiffy =
             physmem->dma_addr(paddr, sizeof(uint32_t));
 
-        Tick cpuFreq = xc->cpu->frequency();
+        Tick cpuFreq = xc->getCpuPtr()->frequency();
         Tick intrFreq = platform->intrFrequency();
         *(uint32_t *)loops_per_jiffy =
             (uint32_t)((cpuFreq / intrFreq) * 0.9988);
@@ -204,7 +204,7 @@ LinuxSystem::SkipDelayLoopEvent::process(ExecContext *xc)
 {
     SkipFuncEvent::process(xc);
     // calculate and set loops_per_jiffy
-    ((LinuxSystem *)xc->system)->setDelayLoop(xc);
+    ((LinuxSystem *)xc->getSystemPtr())->setDelayLoop(xc);
 }
 
 void
@@ -212,7 +212,7 @@ LinuxSystem::DebugPrintkEvent::process(ExecContext *xc)
 {
     if (DTRACE(DebugPrintf)) {
         if (!raw) {
-            StringWrap name(xc->system->name() + ".dprintk");
+            StringWrap name(xc->getSystemPtr()->name() + ".dprintk");
             DPRINTFN("");
         }
 
diff --git a/kern/linux/linux_threadinfo.hh b/kern/linux/linux_threadinfo.hh
index a1c378d6a..f2fb10483 100644
--- a/kern/linux/linux_threadinfo.hh
+++ b/kern/linux/linux_threadinfo.hh
@@ -53,7 +53,7 @@ class ThreadInfo
          * thread_info struct. So we can get the address by masking off
          * the lower 14 bits.
          */
-        current = xc->regs.intRegFile[TheISA::StackPointerReg] & ~0x3fff;
+        current = xc->readIntReg(TheISA::StackPointerReg) & ~0x3fff;
         return VPtr<thread_info>(xc, current);
     }
 
diff --git a/kern/system_events.cc b/kern/system_events.cc
index 91625e60a..9b9861497 100644
--- a/kern/system_events.cc
+++ b/kern/system_events.cc
@@ -34,17 +34,17 @@ using namespace TheISA;
 void
 SkipFuncEvent::process(ExecContext *xc)
 {
-    Addr newpc = xc->regs.intRegFile[ReturnAddressReg];
+    Addr newpc = xc->readIntReg(ReturnAddressReg);
 
     DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
-            xc->regs.pc, newpc);
+            xc->readPC(), newpc);
 
-    xc->regs.pc = newpc;
-    xc->regs.npc = xc->regs.pc + sizeof(MachInst);
+    xc->setPC(newpc);
+    xc->setNextPC(xc->readPC() + sizeof(TheISA::MachInst));
 
-    BranchPred *bp = xc->cpu->getBranchPred();
+    BranchPred *bp = xc->getCpuPtr()->getBranchPred();
     if (bp != NULL) {
-        bp->popRAS(xc->thread_num);
+        bp->popRAS(xc->getThreadNum());
     }
 }
 
@@ -61,20 +61,21 @@ FnEvent::process(ExecContext *xc)
     if (xc->misspeculating())
         return;
 
-    xc->system->kernelBinning->call(xc, mybin);
+    xc->getSystemPtr()->kernelBinning->call(xc, mybin);
 }
 
 void
 IdleStartEvent::process(ExecContext *xc)
 {
-    xc->kernelStats->setIdleProcess(xc->readMiscReg(AlphaISA::IPR_PALtemp23));
+    xc->getCpuPtr()->kernelStats->setIdleProcess(
+        xc->readMiscReg(AlphaISA::IPR_PALtemp23), xc);
     remove();
 }
 
 void
 InterruptStartEvent::process(ExecContext *xc)
 {
-    xc->kernelStats->mode(Kernel::interrupt);
+    xc->getCpuPtr()->kernelStats->mode(Kernel::interrupt, xc);
 }
 
 void
@@ -82,5 +83,5 @@ InterruptEndEvent::process(ExecContext *xc)
 {
     // We go back to kernel, if we are user, inside the rti
     // pal code we will get switched to user because of the ICM write
-    xc->kernelStats->mode(Kernel::kernel);
+    xc->getCpuPtr()->kernelStats->mode(Kernel::kernel, xc);
 }
diff --git a/kern/tru64/dump_mbuf.cc b/kern/tru64/dump_mbuf.cc
index efdaed62d..5ce7570ca 100644
--- a/kern/tru64/dump_mbuf.cc
+++ b/kern/tru64/dump_mbuf.cc
@@ -61,7 +61,7 @@ DumpMbuf(AlphaArguments args)
                  addr, m.m_data, m.m_len);
         char *buffer = new char[m.m_len];
         CopyOut(xc, buffer, m.m_data, m.m_len);
-        Trace::dataDump(curTick, xc->system->name(), (uint8_t *)buffer,
+        Trace::dataDump(curTick, xc->getSystemPtr()->name(), (uint8_t *)buffer,
                         m.m_len);
         delete [] buffer;
 
diff --git a/kern/tru64/tru64.hh b/kern/tru64/tru64.hh
index ad568cb0c..70abfaf6b 100644
--- a/kern/tru64/tru64.hh
+++ b/kern/tru64/tru64.hh
@@ -665,7 +665,7 @@ class Tru64 {
 
         // just pass basep through uninterpreted.
         TypedBufferArg<int64_t> basep(tgt_basep);
-        basep.copyIn(xc->mem);
+        basep.copyIn(xc->getMemPtr());
         long host_basep = (off_t)htog((int64_t)*basep);
         int host_result = getdirentries(fd, host_buf, tgt_nbytes, &host_basep);
 
@@ -692,7 +692,7 @@ class Tru64 {
             tgt_dp->d_reclen = tgt_bufsize;
             tgt_dp->d_namlen = namelen;
             strcpy(tgt_dp->d_name, host_dp->d_name);
-            tgt_dp.copyOut(xc->mem);
+            tgt_dp.copyOut(xc->getMemPtr());
 
             tgt_buf_ptr += tgt_bufsize;
             host_buf_ptr += host_dp->d_reclen;
@@ -701,7 +701,7 @@ class Tru64 {
         delete [] host_buf;
 
         *basep = htog((int64_t)host_basep);
-        basep.copyOut(xc->mem);
+        basep.copyOut(xc->getMemPtr());
 
         return tgt_buf_ptr - tgt_buf;
 #endif
@@ -713,20 +713,19 @@ class Tru64 {
                   ExecContext *xc)
     {
         using TheISA::RegFile;
-        RegFile *regs = &xc->regs;
         TypedBufferArg<Tru64::sigcontext> sc(xc->getSyscallArg(0));
 
-        sc.copyIn(xc->mem);
+        sc.copyIn(xc->getMemPtr());
 
         // Restore state from sigcontext structure.
         // Note that we'll advance PC <- NPC before the end of the cycle,
         // so we need to restore the desired PC into NPC.
         // The current regs->pc will get clobbered.
-        regs->npc = htog(sc->sc_pc);
+        xc->setNextPC(htog(sc->sc_pc));
 
         for (int i = 0; i < 31; ++i) {
-            regs->intRegFile[i] = htog(sc->sc_regs[i]);
-            regs->floatRegFile.q[i] = htog(sc->sc_fpregs[i]);
+            xc->setIntReg(i, htog(sc->sc_regs[i]));
+            xc->setFloatRegInt(i, htog(sc->sc_fpregs[i]));
         }
 
         xc->setMiscReg(TheISA::Fpcr_DepTag, htog(sc->sc_fpcr));
@@ -761,7 +760,7 @@ class Tru64 {
               elp->si_phz = htog(clk_hz);
               elp->si_boottime = htog(seconds_since_epoch); // seconds since epoch?
               elp->si_max_procs = htog(process->numCpus());
-              elp.copyOut(xc->mem);
+              elp.copyOut(xc->getMemPtr());
               return 0;
           }
 
@@ -782,7 +781,7 @@ class Tru64 {
     {
         TypedBufferArg<Tru64::vm_stack> argp(xc->getSyscallArg(0));
 
-        argp.copyIn(xc->mem);
+        argp.copyIn(xc->getMemPtr());
 
         // if the user chose an address, just let them have it.  Otherwise
         // pick one for them.
@@ -791,7 +790,7 @@ class Tru64 {
             int stack_size = (htog(argp->rsize) + htog(argp->ysize) +
                     htog(argp->gsize));
             process->next_thread_stack_base -= stack_size;
-            argp.copyOut(xc->mem);
+            argp.copyOut(xc->getMemPtr());
         }
 
         return 0;
@@ -811,7 +810,7 @@ class Tru64 {
         TypedBufferArg<Tru64::nxm_task_attr> attrp(xc->getSyscallArg(0));
         TypedBufferArg<Addr> configptr_ptr(xc->getSyscallArg(1));
 
-        attrp.copyIn(xc->mem);
+        attrp.copyIn(xc->getMemPtr());
 
         if (gtoh(attrp->nxm_version) != NXM_LIB_VERSION) {
             cerr << "nxm_task_init: thread library version mismatch! "
@@ -852,7 +851,7 @@ class Tru64 {
         config->nxm_slot_state = htog(slot_state_addr);
         config->nxm_rad[0] = htog(rad_state_addr);
 
-        config.copyOut(xc->mem);
+        config.copyOut(xc->getMemPtr());
 
         // initialize the slot_state array and copy it out
         TypedBufferArg<Tru64::nxm_slot_state_t> slot_state(slot_state_addr,
@@ -865,7 +864,7 @@ class Tru64 {
                 (i == 0) ? Tru64::NXM_SLOT_BOUND : Tru64::NXM_SLOT_AVAIL;
         }
 
-        slot_state.copyOut(xc->mem);
+        slot_state.copyOut(xc->getMemPtr());
 
         // same for the per-RAD "shared" struct.  Note that we need to
         // allocate extra bytes for the per-VP array which is embedded at
@@ -899,13 +898,13 @@ class Tru64 {
             }
         }
 
-        rad_state.copyOut(xc->mem);
+        rad_state.copyOut(xc->getMemPtr());
 
         //
         // copy pointer to shared config area out to user
         //
         *configptr_ptr = htog(config_addr);
-        configptr_ptr.copyOut(xc->mem);
+        configptr_ptr.copyOut(xc->getMemPtr());
 
         // Register this as a valid address range with the process
         process->nxm_start = base_addr;
@@ -919,15 +918,15 @@ class Tru64 {
     init_exec_context(ExecContext *ec,
                       Tru64::nxm_thread_attr *attrp, uint64_t uniq_val)
     {
-        memset(&ec->regs, 0, sizeof(ec->regs));
+        ec->clearArchRegs();
 
-        ec->regs.intRegFile[TheISA::ArgumentReg0] = gtoh(attrp->registers.a0);
-        ec->regs.intRegFile[27/*t12*/] = gtoh(attrp->registers.pc);
-        ec->regs.intRegFile[TheISA::StackPointerReg] = gtoh(attrp->registers.sp);
+        ec->setIntReg(TheISA::ArgumentReg0, gtoh(attrp->registers.a0));
+        ec->setIntReg(27/*t12*/, gtoh(attrp->registers.pc));
+        ec->setIntReg(TheISA::StackPointerReg, gtoh(attrp->registers.sp));
         ec->setMiscReg(TheISA::Uniq_DepTag, uniq_val);
 
-        ec->regs.pc = gtoh(attrp->registers.pc);
-        ec->regs.npc = gtoh(attrp->registers.pc) + sizeof(TheISA::MachInst);
+        ec->setPC(gtoh(attrp->registers.pc));
+        ec->setNextPC(gtoh(attrp->registers.pc) + sizeof(TheISA::MachInst));
 
         ec->activate();
     }
@@ -942,7 +941,7 @@ class Tru64 {
         int thread_index = xc->getSyscallArg(2);
 
         // get attribute args
-        attrp.copyIn(xc->mem);
+        attrp.copyIn(xc->getMemPtr());
 
         if (gtoh(attrp->version) != NXM_LIB_VERSION) {
             cerr << "nxm_thread_create: thread library version mismatch! "
@@ -967,7 +966,7 @@ class Tru64 {
 
         TypedBufferArg<Tru64::nxm_shared> rad_state(0x14000,
                                                     rad_state_size);
-        rad_state.copyIn(xc->mem);
+        rad_state.copyIn(xc->getMemPtr());
 
         uint64_t uniq_val = gtoh(attrp->pthid) - gtoh(rad_state->nxm_uniq_offset);
 
@@ -978,7 +977,7 @@ class Tru64 {
 
             // This is supposed to be a port number.  Make something up.
             *kidp = htog(99);
-            kidp.copyOut(xc->mem);
+            kidp.copyOut(xc->getMemPtr());
 
             return 0;
         } else if (gtoh(attrp->type) == Tru64::NXM_TYPE_VP) {
@@ -992,7 +991,7 @@ class Tru64 {
             ssp->nxm_u.pth_id = attrp->pthid;
             ssp->nxm_u.nxm_active = htog(uniq_val | 1);
 
-            rad_state.copyOut(xc->mem);
+            rad_state.copyOut(xc->getMemPtr());
 
             Addr slot_state_addr = 0x12000 + sizeof(Tru64::nxm_config_info);
             int slot_state_size =
@@ -1002,7 +1001,7 @@ class Tru64 {
                 slot_state(slot_state_addr,
                            slot_state_size);
 
-            slot_state.copyIn(xc->mem);
+            slot_state.copyIn(xc->getMemPtr());
 
             if (slot_state[thread_index] != Tru64::NXM_SLOT_AVAIL) {
                 cerr << "nxm_thread_createFunc: requested VP slot "
@@ -1014,7 +1013,7 @@ class Tru64 {
             // doesn't work anyway
             slot_state[thread_index] = Tru64::NXM_SLOT_BOUND;
 
-            slot_state.copyOut(xc->mem);
+            slot_state.copyOut(xc->getMemPtr());
 
             // Find a free simulator execution context.
             for (int i = 0; i < process->numCpus(); ++i) {
@@ -1028,7 +1027,7 @@ class Tru64 {
                     // and get away with just sticking the thread index
                     // here.
                     *kidp = htog(thread_index);
-                    kidp.copyOut(xc->mem);
+                    kidp.copyOut(xc->getMemPtr());
 
                     return 0;
                 }
@@ -1065,8 +1064,8 @@ class Tru64 {
         uint64_t action = xc->getSyscallArg(3);
         uint64_t usecs = xc->getSyscallArg(4);
 
-        cout << xc->cpu->name() << ": nxm_thread_block " << tid << " " << secs
-             << " " << flags << " " << action << " " << usecs << endl;
+        cout << xc->getCpuPtr()->name() << ": nxm_thread_block " << tid << " "
+             << secs << " " << flags << " " << action << " " << usecs << endl;
 
         return 0;
     }
@@ -1082,7 +1081,7 @@ class Tru64 {
         uint64_t usecs = xc->getSyscallArg(3);
         uint64_t flags = xc->getSyscallArg(4);
 
-        BaseCPU *cpu = xc->cpu;
+        BaseCPU *cpu = xc->getCpuPtr();
 
         cout << cpu->name() << ": nxm_block "
              << hex << uaddr << dec << " " << val
@@ -1099,7 +1098,7 @@ class Tru64 {
     {
         Addr uaddr = xc->getSyscallArg(0);
 
-        cout << xc->cpu->name() << ": nxm_unblock "
+        cout << xc->getCpuPtr()->name() << ": nxm_unblock "
              << hex << uaddr << dec << endl;
 
         return 0;
@@ -1157,12 +1156,12 @@ class Tru64 {
     {
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->mem);
+        lockp.copyIn(xc->getMemPtr());
 
         if (gtoh(*lockp) == 0) {
             // lock is free: grab it
             *lockp = htog(1);
-            lockp.copyOut(xc->mem);
+            lockp.copyOut(xc->getMemPtr());
         } else {
             // lock is busy: disable until free
             process->waitList.push_back(Process::WaitRec(uaddr, xc));
@@ -1176,7 +1175,7 @@ class Tru64 {
     {
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->mem);
+        lockp.copyIn(xc->getMemPtr());
         assert(*lockp != 0);
 
         // Check for a process waiting on the lock.
@@ -1185,7 +1184,7 @@ class Tru64 {
         // clear lock field if no waiting context is taking over the lock
         if (num_waiting == 0) {
             *lockp = 0;
-            lockp.copyOut(xc->mem);
+            lockp.copyOut(xc->getMemPtr());
         }
     }
 
@@ -1212,12 +1211,12 @@ class Tru64 {
         Addr uaddr = xc->getSyscallArg(0);
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->mem);
+        lockp.copyIn(xc->getMemPtr());
 
         if (gtoh(*lockp) == 0) {
             // lock is free: grab it
             *lockp = htog(1);
-            lockp.copyOut(xc->mem);
+            lockp.copyOut(xc->getMemPtr());
             return 0;
         } else {
             return 1;
@@ -1272,7 +1271,7 @@ class Tru64 {
         TypedBufferArg<uint64_t> lockp(lock_addr);
 
         // user is supposed to acquire lock before entering
-        lockp.copyIn(xc->mem);
+        lockp.copyIn(xc->getMemPtr());
         assert(gtoh(*lockp) != 0);
 
         m5_unlock_mutex(lock_addr, process, xc);
diff --git a/kern/tru64/tru64_events.cc b/kern/tru64/tru64_events.cc
index 2fe6a2dc4..d41aa5f61 100644
--- a/kern/tru64/tru64_events.cc
+++ b/kern/tru64/tru64_events.cc
@@ -47,13 +47,14 @@ BadAddrEvent::process(ExecContext *xc)
     // annotation for vmunix::badaddr in:
     // simos/simulation/apps/tcl/osf/tlaser.tcl
 
-    uint64_t a0 = xc->regs.intRegFile[ArgumentReg0];
+    uint64_t a0 = xc->readIntReg(ArgumentReg0);
 
     if (!TheISA::IsK0Seg(a0) ||
-        xc->memctrl->badaddr(TheISA::K0Seg2Phys(a0) & EV5::PAddrImplMask)) {
+        xc->getSystemPtr()->memctrl->badaddr(
+            TheISA::K0Seg2Phys(a0) & EV5::PAddrImplMask)) {
 
         DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
-        xc->regs.intRegFile[ReturnValueReg] = 0x1;
+        xc->setIntReg(ReturnValueReg, 0x1);
         SkipFuncEvent::process(xc);
     }
     else
@@ -64,7 +65,7 @@ void
 PrintfEvent::process(ExecContext *xc)
 {
     if (DTRACE(Printf)) {
-        DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
+        DebugOut() << curTick << ": " << xc->getCpuPtr()->name() << ": ";
 
         AlphaArguments args(xc);
         tru64::Printf(args);
@@ -76,7 +77,7 @@ DebugPrintfEvent::process(ExecContext *xc)
 {
     if (DTRACE(DebugPrintf)) {
         if (!raw)
-            DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
+            DebugOut() << curTick << ": " << xc->getCpuPtr()->name() << ": ";
 
         AlphaArguments args(xc);
         tru64::Printf(args);