Change ExecContext to ThreadContext. This is being renamed to differentiate between the interface used objects outside of the CPU, and the interface used by the ISA. ThreadContext is used by objects outside of the CPU and is specifically defined in thread_context.hh. ExecContext is more implicit, and is defined by files such as base_dyn_inst.hh or cpu/simple/base.hh.

Further renames/reorganization will be coming shortly; what is currently CPUExecContext (the old ExecContext from m5) will be renamed to SimpleThread or something similar.

src/arch/alpha/arguments.cc:
src/arch/alpha/arguments.hh:
src/arch/alpha/ev5.cc:
src/arch/alpha/faults.cc:
src/arch/alpha/faults.hh:
src/arch/alpha/freebsd/system.cc:
src/arch/alpha/freebsd/system.hh:
src/arch/alpha/isa/branch.isa:
src/arch/alpha/isa/decoder.isa:
src/arch/alpha/isa/main.isa:
src/arch/alpha/linux/process.cc:
src/arch/alpha/linux/system.cc:
src/arch/alpha/linux/system.hh:
src/arch/alpha/linux/threadinfo.hh:
src/arch/alpha/process.cc:
src/arch/alpha/regfile.hh:
src/arch/alpha/stacktrace.cc:
src/arch/alpha/stacktrace.hh:
src/arch/alpha/tlb.cc:
src/arch/alpha/tlb.hh:
src/arch/alpha/tru64/process.cc:
src/arch/alpha/tru64/system.cc:
src/arch/alpha/tru64/system.hh:
src/arch/alpha/utility.hh:
src/arch/alpha/vtophys.cc:
src/arch/alpha/vtophys.hh:
src/arch/mips/faults.cc:
src/arch/mips/faults.hh:
src/arch/mips/isa_traits.cc:
src/arch/mips/isa_traits.hh:
src/arch/mips/linux/process.cc:
src/arch/mips/process.cc:
src/arch/mips/regfile/float_regfile.hh:
src/arch/mips/regfile/int_regfile.hh:
src/arch/mips/regfile/misc_regfile.hh:
src/arch/mips/regfile/regfile.hh:
src/arch/mips/stacktrace.hh:
src/arch/sparc/faults.cc:
src/arch/sparc/faults.hh:
src/arch/sparc/isa_traits.hh:
src/arch/sparc/linux/process.cc:
src/arch/sparc/linux/process.hh:
src/arch/sparc/process.cc:
src/arch/sparc/regfile.hh:
src/arch/sparc/solaris/process.cc:
src/arch/sparc/stacktrace.hh:
src/arch/sparc/ua2005.cc:
src/arch/sparc/utility.hh:
src/arch/sparc/vtophys.cc:
src/arch/sparc/vtophys.hh:
src/base/remote_gdb.cc:
src/base/remote_gdb.hh:
src/cpu/base.cc:
src/cpu/base.hh:
src/cpu/base_dyn_inst.hh:
src/cpu/checker/cpu.cc:
src/cpu/checker/cpu.hh:
src/cpu/checker/exec_context.hh:
src/cpu/cpu_exec_context.cc:
src/cpu/cpu_exec_context.hh:
src/cpu/cpuevent.cc:
src/cpu/cpuevent.hh:
src/cpu/exetrace.hh:
src/cpu/intr_control.cc:
src/cpu/memtest/memtest.hh:
src/cpu/o3/alpha_cpu.hh:
src/cpu/o3/alpha_cpu_impl.hh:
src/cpu/o3/alpha_dyn_inst_impl.hh:
src/cpu/o3/commit.hh:
src/cpu/o3/commit_impl.hh:
src/cpu/o3/cpu.cc:
src/cpu/o3/cpu.hh:
src/cpu/o3/fetch_impl.hh:
src/cpu/o3/regfile.hh:
src/cpu/o3/thread_state.hh:
src/cpu/ozone/back_end.hh:
src/cpu/ozone/cpu.hh:
src/cpu/ozone/cpu_impl.hh:
src/cpu/ozone/front_end.hh:
src/cpu/ozone/front_end_impl.hh:
src/cpu/ozone/inorder_back_end.hh:
src/cpu/ozone/lw_back_end.hh:
src/cpu/ozone/lw_back_end_impl.hh:
src/cpu/ozone/lw_lsq.hh:
src/cpu/ozone/lw_lsq_impl.hh:
src/cpu/ozone/thread_state.hh:
src/cpu/pc_event.cc:
src/cpu/pc_event.hh:
src/cpu/profile.cc:
src/cpu/profile.hh:
src/cpu/quiesce_event.cc:
src/cpu/quiesce_event.hh:
src/cpu/simple/atomic.cc:
src/cpu/simple/base.cc:
src/cpu/simple/base.hh:
src/cpu/simple/timing.cc:
src/cpu/static_inst.cc:
src/cpu/static_inst.hh:
src/cpu/thread_state.hh:
src/dev/alpha_console.cc:
src/dev/ns_gige.cc:
src/dev/sinic.cc:
src/dev/tsunami_cchip.cc:
src/kern/kernel_stats.cc:
src/kern/kernel_stats.hh:
src/kern/linux/events.cc:
src/kern/linux/events.hh:
src/kern/system_events.cc:
src/kern/system_events.hh:
src/kern/tru64/dump_mbuf.cc:
src/kern/tru64/tru64.hh:
src/kern/tru64/tru64_events.cc:
src/kern/tru64/tru64_events.hh:
src/mem/vport.cc:
src/mem/vport.hh:
src/sim/faults.cc:
src/sim/faults.hh:
src/sim/process.cc:
src/sim/process.hh:
src/sim/pseudo_inst.cc:
src/sim/pseudo_inst.hh:
src/sim/syscall_emul.cc:
src/sim/syscall_emul.hh:
src/sim/system.cc:
src/cpu/thread_context.hh:
src/sim/system.hh:
src/sim/vptr.hh:
    Change ExecContext to ThreadContext.

--HG--
rename : src/cpu/exec_context.hh => src/cpu/thread_context.hh
extra : convert_revision : 108bb97d15a114a565a2a6a23faa554f4e2fd77e

10 files changed, 191 insertions, 191 deletions

diff --git a/src/kern/kernel_stats.cc b/src/kern/kernel_stats.cc
index 7927ad931..2ba120b6f 100644
--- a/src/kern/kernel_stats.cc
+++ b/src/kern/kernel_stats.cc
@@ -35,7 +35,7 @@
 
 #include "arch/alpha/osfpal.hh"
 #include "base/trace.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "kern/kernel_stats.hh"
 #include "kern/tru64/tru64_syscalls.hh"
 #include "sim/system.hh"
@@ -184,16 +184,16 @@ Statistics::regStats(const string &_name)
 }
 
 void
-Statistics::setIdleProcess(Addr idlepcbb, ExecContext *xc)
+Statistics::setIdleProcess(Addr idlepcbb, ThreadContext *tc)
 {
     assert(themode == kernel || themode == interrupt);
     idleProcess = idlepcbb;
     themode = idle;
-    changeMode(themode, xc);
+    changeMode(themode, tc);
 }
 
 void
-Statistics::changeMode(cpu_mode newmode, ExecContext *xc)
+Statistics::changeMode(cpu_mode newmode, ThreadContext *tc)
 {
     _mode[newmode]++;
 
@@ -206,7 +206,7 @@ Statistics::changeMode(cpu_mode newmode, ExecContext *xc)
     _modeGood[newmode]++;
     _modeTicks[themode] += curTick - lastModeTick;
 
-    xc->getSystemPtr()->kernelBinning->changeMode(newmode);
+    tc->getSystemPtr()->kernelBinning->changeMode(newmode);
 
     lastModeTick = curTick;
     themode = newmode;
@@ -229,9 +229,9 @@ Statistics::swpipl(int ipl)
 }
 
 void
-Statistics::mode(cpu_mode newmode, ExecContext *xc)
+Statistics::mode(cpu_mode newmode, ThreadContext *tc)
 {
-    Addr pcbb = xc->readMiscReg(AlphaISA::IPR_PALtemp23);
+    Addr pcbb = tc->readMiscReg(AlphaISA::IPR_PALtemp23);
 
     if ((newmode == kernel || newmode == interrupt) &&
             pcbb == idleProcess)
@@ -240,20 +240,20 @@ Statistics::mode(cpu_mode newmode, ExecContext *xc)
     if (bin_int == false && newmode == interrupt)
         newmode = kernel;
 
-    changeMode(newmode, xc);
+    changeMode(newmode, tc);
 }
 
 void
-Statistics::context(Addr oldpcbb, Addr newpcbb, ExecContext *xc)
+Statistics::context(Addr oldpcbb, Addr newpcbb, ThreadContext *tc)
 {
     assert(themode != user);
 
     _swap_context++;
-    changeMode(newpcbb == idleProcess ? idle : kernel, xc);
+    changeMode(newpcbb == idleProcess ? idle : kernel, tc);
 }
 
 void
-Statistics::callpal(int code, ExecContext *xc)
+Statistics::callpal(int code, ThreadContext *tc)
 {
     if (!PAL::name(code))
         return;
@@ -262,7 +262,7 @@ Statistics::callpal(int code, ExecContext *xc)
 
     switch (code) {
       case PAL::callsys: {
-          int number = xc->readIntReg(0);
+          int number = tc->readIntReg(0);
           if (SystemCalls<Tru64>::validSyscallNumber(number)) {
               int cvtnum = SystemCalls<Tru64>::convert(number);
               _syscall[cvtnum]++;
@@ -270,8 +270,8 @@ Statistics::callpal(int code, ExecContext *xc)
       } break;
 
       case PAL::swpctx:
-        if (xc->getSystemPtr()->kernelBinning)
-            xc->getSystemPtr()->kernelBinning->palSwapContext(xc);
+        if (tc->getSystemPtr()->kernelBinning)
+            tc->getSystemPtr()->kernelBinning->palSwapContext(tc);
         break;
     }
 }
diff --git a/src/kern/kernel_stats.hh b/src/kern/kernel_stats.hh
index 5e2c7daf8..781b6f6da 100644
--- a/src/kern/kernel_stats.hh
+++ b/src/kern/kernel_stats.hh
@@ -40,7 +40,7 @@
 #include "cpu/static_inst.hh"
 
 class BaseCPU;
-class ExecContext;
+class ThreadContext;
 class FnEvent;
 // What does kernel stats expect is included?
 class System;
@@ -107,9 +107,9 @@ class Binning
     const bool fnbin;
 
     cpu_mode themode;
-    void palSwapContext(ExecContext *xc);
-    void execute(ExecContext *xc, StaticInstPtr inst);
-    void call(ExecContext *xc, Stats::MainBin *myBin);
+    void palSwapContext(ThreadContext *tc);
+    void execute(ThreadContext *tc, StaticInstPtr inst);
+    void call(ThreadContext *tc, Stats::MainBin *myBin);
     void changeMode(cpu_mode mode);
 
   public:
@@ -137,7 +137,7 @@ class Statistics : public Serializable
     Tick lastModeTick;
     bool bin_int;
 
-    void changeMode(cpu_mode newmode, ExecContext *xc);
+    void changeMode(cpu_mode newmode, ThreadContext *tc);
 
   private:
     Stats::Scalar<> _arm;
@@ -179,11 +179,11 @@ class Statistics : public Serializable
     void ivle() { _ivle++; }
     void hwrei() { _hwrei++; }
     void swpipl(int ipl);
-    void mode(cpu_mode newmode, ExecContext *xc);
-    void context(Addr oldpcbb, Addr newpcbb, ExecContext *xc);
-    void callpal(int code, ExecContext *xc);
+    void mode(cpu_mode newmode, ThreadContext *tc);
+    void context(Addr oldpcbb, Addr newpcbb, ThreadContext *tc);
+    void callpal(int code, ThreadContext *tc);
 
-    void setIdleProcess(Addr idle, ExecContext *xc);
+    void setIdleProcess(Addr idle, ThreadContext *tc);
 
   public:
     virtual void serialize(std::ostream &os);
diff --git a/src/kern/linux/events.cc b/src/kern/linux/events.cc
index 425109053..5ff7e26db 100644
--- a/src/kern/linux/events.cc
+++ b/src/kern/linux/events.cc
@@ -30,7 +30,7 @@
 
 #include "arch/arguments.hh"
 #include "base/trace.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "kern/linux/events.hh"
 #include "kern/linux/printk.hh"
 #include "kern/system_events.hh"
@@ -40,17 +40,17 @@
 namespace Linux {
 
 void
-DebugPrintkEvent::process(ExecContext *xc)
+DebugPrintkEvent::process(ThreadContext *tc)
 {
     if (DTRACE(DebugPrintf)) {
         if (!raw) {
-            StringWrap name(xc->getSystemPtr()->name() + ".dprintk");
+            StringWrap name(tc->getSystemPtr()->name() + ".dprintk");
             DPRINTFN("");
         }
 
-        AlphaISA::AlphaArguments args(xc);
+        AlphaISA::AlphaArguments args(tc);
         Printk(args);
-        SkipFuncEvent::process(xc);
+        SkipFuncEvent::process(tc);
     }
 }
 
diff --git a/src/kern/linux/events.hh b/src/kern/linux/events.hh
index 0e4c433e1..65f794a9c 100644
--- a/src/kern/linux/events.hh
+++ b/src/kern/linux/events.hh
@@ -44,7 +44,7 @@ class DebugPrintkEvent : public SkipFuncEvent
     DebugPrintkEvent(PCEventQueue *q, const std::string &desc, Addr addr,
                      bool r = false)
         : SkipFuncEvent(q, desc, addr), raw(r) {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *xc);
 };
 
 }
diff --git a/src/kern/system_events.cc b/src/kern/system_events.cc
index af700039c..aca75e27d 100644
--- a/src/kern/system_events.cc
+++ b/src/kern/system_events.cc
@@ -38,19 +38,19 @@
 using namespace TheISA;
 
 void
-SkipFuncEvent::process(ExecContext *xc)
+SkipFuncEvent::process(ThreadContext *tc)
 {
-    Addr newpc = xc->readIntReg(ReturnAddressReg);
+    Addr newpc = tc->readIntReg(ReturnAddressReg);
 
     DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
-            xc->readPC(), newpc);
+            tc->readPC(), newpc);
 
-    xc->setPC(newpc);
-    xc->setNextPC(xc->readPC() + sizeof(TheISA::MachInst));
+    tc->setPC(newpc);
+    tc->setNextPC(tc->readPC() + sizeof(TheISA::MachInst));
 /*
-    BranchPred *bp = xc->getCpuPtr()->getBranchPred();
+    BranchPred *bp = tc->getCpuPtr()->getBranchPred();
     if (bp != NULL) {
-        bp->popRAS(xc->getThreadNum());
+        bp->popRAS(tc->getThreadNum());
     }
 */
 }
@@ -63,35 +63,35 @@ FnEvent::FnEvent(PCEventQueue *q, const std::string &desc, Addr addr,
 }
 
 void
-FnEvent::process(ExecContext *xc)
+FnEvent::process(ThreadContext *tc)
 {
-    if (xc->misspeculating())
+    if (tc->misspeculating())
         return;
 
-    xc->getSystemPtr()->kernelBinning->call(xc, mybin);
+    tc->getSystemPtr()->kernelBinning->call(tc, mybin);
 }
 
 void
-IdleStartEvent::process(ExecContext *xc)
+IdleStartEvent::process(ThreadContext *tc)
 {
-    if (xc->getKernelStats())
-        xc->getKernelStats()->setIdleProcess(
-            xc->readMiscReg(AlphaISA::IPR_PALtemp23), xc);
+    if (tc->getKernelStats())
+        tc->getKernelStats()->setIdleProcess(
+            tc->readMiscReg(AlphaISA::IPR_PALtemp23), tc);
     remove();
 }
 
 void
-InterruptStartEvent::process(ExecContext *xc)
+InterruptStartEvent::process(ThreadContext *tc)
 {
-    if (xc->getKernelStats())
-        xc->getKernelStats()->mode(Kernel::interrupt, xc);
+    if (tc->getKernelStats())
+        tc->getKernelStats()->mode(Kernel::interrupt, tc);
 }
 
 void
-InterruptEndEvent::process(ExecContext *xc)
+InterruptEndEvent::process(ThreadContext *tc)
 {
     // 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
-    if (xc->getKernelStats())
-        xc->getKernelStats()->mode(Kernel::kernel, xc);
+    if (tc->getKernelStats())
+        tc->getKernelStats()->mode(Kernel::kernel, tc);
 }
diff --git a/src/kern/system_events.hh b/src/kern/system_events.hh
index ea3601a89..05c878577 100644
--- a/src/kern/system_events.hh
+++ b/src/kern/system_events.hh
@@ -42,7 +42,7 @@ class SkipFuncEvent : public PCEvent
     SkipFuncEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr)
     {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class FnEvent : public PCEvent
@@ -50,7 +50,7 @@ class FnEvent : public PCEvent
   public:
     FnEvent(PCEventQueue *q, const std::string &desc, Addr addr,
             Stats::MainBin *bin);
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
     std::string myname() const { return _name; }
 
   private:
@@ -64,7 +64,7 @@ class IdleStartEvent : public PCEvent
     IdleStartEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr)
     {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class InterruptStartEvent : public PCEvent
@@ -73,7 +73,7 @@ class InterruptStartEvent : public PCEvent
     InterruptStartEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr)
     {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class InterruptEndEvent : public PCEvent
@@ -82,7 +82,7 @@ class InterruptEndEvent : public PCEvent
     InterruptEndEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr)
     {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 
diff --git a/src/kern/tru64/dump_mbuf.cc b/src/kern/tru64/dump_mbuf.cc
index 44f18e62f..8f88f8904 100644
--- a/src/kern/tru64/dump_mbuf.cc
+++ b/src/kern/tru64/dump_mbuf.cc
@@ -34,7 +34,7 @@
 #include "base/cprintf.hh"
 #include "base/trace.hh"
 #include "base/loader/symtab.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "kern/tru64/mbuf.hh"
 #include "sim/host.hh"
 #include "sim/system.hh"
@@ -49,11 +49,11 @@ namespace tru64 {
 void
 DumpMbuf(AlphaArguments args)
 {
-    ExecContext *xc = args.getExecContext();
+    ThreadContext *tc = args.getThreadContext();
     Addr addr = (Addr)args;
     struct mbuf m;
 
-    CopyOut(xc, &m, addr, sizeof(m));
+    CopyOut(tc, &m, addr, sizeof(m));
 
     int count = m.m_pkthdr.len;
 
@@ -64,8 +64,8 @@ DumpMbuf(AlphaArguments args)
         ccprintf(DebugOut(), "m=%#lx, m->m_data=%#lx, m->m_len=%d\n",
                  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->getSystemPtr()->name(), (uint8_t *)buffer,
+        CopyOut(tc, buffer, m.m_data, m.m_len);
+        Trace::dataDump(curTick, tc->getSystemPtr()->name(), (uint8_t *)buffer,
                         m.m_len);
         delete [] buffer;
 
@@ -73,7 +73,7 @@ DumpMbuf(AlphaArguments args)
         if (!m.m_next)
             break;
 
-        CopyOut(xc, &m, m.m_next, sizeof(m));
+        CopyOut(tc, &m, m.m_next, sizeof(m));
     }
 }
 
diff --git a/src/kern/tru64/tru64.hh b/src/kern/tru64/tru64.hh
index ee41ec736..d2b7c862f 100644
--- a/src/kern/tru64/tru64.hh
+++ b/src/kern/tru64/tru64.hh
@@ -579,23 +579,23 @@ class Tru64 {
     /// Target getdirentries() handler.
     static SyscallReturn
     getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process,
-                      ExecContext *xc)
+                      ThreadContext *tc)
     {
         using namespace TheISA;
 
 #ifdef __CYGWIN__
         panic("getdirent not implemented on cygwin!");
 #else
-        int fd = process->sim_fd(xc->getSyscallArg(0));
-        Addr tgt_buf = xc->getSyscallArg(1);
-        int tgt_nbytes = xc->getSyscallArg(2);
-        Addr tgt_basep = xc->getSyscallArg(3);
+        int fd = process->sim_fd(tc->getSyscallArg(0));
+        Addr tgt_buf = tc->getSyscallArg(1);
+        int tgt_nbytes = tc->getSyscallArg(2);
+        Addr tgt_basep = tc->getSyscallArg(3);
 
         char * const host_buf = new char[tgt_nbytes];
 
         // just pass basep through uninterpreted.
         TypedBufferArg<int64_t> basep(tgt_basep);
-        basep.copyIn(xc->getMemPort());
+        basep.copyIn(tc->getMemPort());
         long host_basep = (off_t)htog((int64_t)*basep);
         int host_result = getdirentries(fd, host_buf, tgt_nbytes, &host_basep);
 
@@ -622,7 +622,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->getMemPort());
+            tgt_dp.copyOut(tc->getMemPort());
 
             tgt_buf_ptr += tgt_bufsize;
             host_buf_ptr += host_dp->d_reclen;
@@ -631,7 +631,7 @@ class Tru64 {
         delete [] host_buf;
 
         *basep = htog((int64_t)host_basep);
-        basep.copyOut(xc->getMemPort());
+        basep.copyOut(tc->getMemPort());
 
         return tgt_buf_ptr - tgt_buf;
 #endif
@@ -640,27 +640,27 @@ class Tru64 {
     /// Target sigreturn() handler.
     static SyscallReturn
     sigreturnFunc(SyscallDesc *desc, int callnum, Process *process,
-                  ExecContext *xc)
+                  ThreadContext *tc)
     {
         using namespace TheISA;
 
         using TheISA::RegFile;
-        TypedBufferArg<Tru64::sigcontext> sc(xc->getSyscallArg(0));
+        TypedBufferArg<Tru64::sigcontext> sc(tc->getSyscallArg(0));
 
-        sc.copyIn(xc->getMemPort());
+        sc.copyIn(tc->getMemPort());
 
         // 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.
-        xc->setNextPC(htog(sc->sc_pc));
+        tc->setNextPC(htog(sc->sc_pc));
 
         for (int i = 0; i < 31; ++i) {
-            xc->setIntReg(i, htog(sc->sc_regs[i]));
-            xc->setFloatRegBits(i, htog(sc->sc_fpregs[i]));
+            tc->setIntReg(i, htog(sc->sc_regs[i]));
+            tc->setFloatRegBits(i, htog(sc->sc_fpregs[i]));
         }
 
-        xc->setMiscReg(TheISA::Fpcr_DepTag, htog(sc->sc_fpcr));
+        tc->setMiscReg(TheISA::Fpcr_DepTag, htog(sc->sc_fpcr));
 
         return 0;
     }
@@ -673,13 +673,13 @@ class Tru64 {
     /// Create a stack region for a thread.
     static SyscallReturn
     stack_createFunc(SyscallDesc *desc, int callnum, Process *process,
-                     ExecContext *xc)
+                     ThreadContext *tc)
     {
         using namespace TheISA;
 
-        TypedBufferArg<Tru64::vm_stack> argp(xc->getSyscallArg(0));
+        TypedBufferArg<Tru64::vm_stack> argp(tc->getSyscallArg(0));
 
-        argp.copyIn(xc->getMemPort());
+        argp.copyIn(tc->getMemPort());
 
         // if the user chose an address, just let them have it.  Otherwise
         // pick one for them.
@@ -688,7 +688,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->getMemPort());
+            argp.copyOut(tc->getMemPort());
         }
 
         return 0;
@@ -703,15 +703,15 @@ class Tru64 {
     /// region has several structs, some global, some per-RAD, some per-VP.
     static SyscallReturn
     nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process,
-                      ExecContext *xc)
+                      ThreadContext *tc)
     {
         using namespace std;
         using namespace TheISA;
 
-        TypedBufferArg<Tru64::nxm_task_attr> attrp(xc->getSyscallArg(0));
-        TypedBufferArg<Addr> configptr_ptr(xc->getSyscallArg(1));
+        TypedBufferArg<Tru64::nxm_task_attr> attrp(tc->getSyscallArg(0));
+        TypedBufferArg<Addr> configptr_ptr(tc->getSyscallArg(1));
 
-        attrp.copyIn(xc->getMemPort());
+        attrp.copyIn(tc->getMemPort());
 
         if (gtoh(attrp->nxm_version) != NXM_LIB_VERSION) {
             cerr << "nxm_task_init: thread library version mismatch! "
@@ -752,7 +752,7 @@ class Tru64 {
         config->nxm_slot_state = htog(slot_state_addr);
         config->nxm_rad[0] = htog(rad_state_addr);
 
-        config.copyOut(xc->getMemPort());
+        config.copyOut(tc->getMemPort());
 
         // initialize the slot_state array and copy it out
         TypedBufferArg<Tru64::nxm_slot_state_t> slot_state(slot_state_addr,
@@ -765,7 +765,7 @@ class Tru64 {
                 (i == 0) ? Tru64::NXM_SLOT_BOUND : Tru64::NXM_SLOT_AVAIL;
         }
 
-        slot_state.copyOut(xc->getMemPort());
+        slot_state.copyOut(tc->getMemPort());
 
         // same for the per-RAD "shared" struct.  Note that we need to
         // allocate extra bytes for the per-VP array which is embedded at
@@ -789,7 +789,7 @@ class Tru64 {
             ssp->nxm_sysevent = htog(0);
 
             if (i == 0) {
-                uint64_t uniq = xc->readMiscReg(TheISA::Uniq_DepTag);
+                uint64_t uniq = tc->readMiscReg(TheISA::Uniq_DepTag);
                 ssp->nxm_u.pth_id = htog(uniq + gtoh(attrp->nxm_uniq_offset));
                 ssp->nxm_u.nxm_active = htog(uniq | 1);
             }
@@ -799,13 +799,13 @@ class Tru64 {
             }
         }
 
-        rad_state.copyOut(xc->getMemPort());
+        rad_state.copyOut(tc->getMemPort());
 
         //
         // copy pointer to shared config area out to user
         //
         *configptr_ptr = htog(config_addr);
-        configptr_ptr.copyOut(xc->getMemPort());
+        configptr_ptr.copyOut(tc->getMemPort());
 
         // Register this as a valid address range with the process
         process->nxm_start = base_addr;
@@ -814,40 +814,40 @@ class Tru64 {
         return 0;
     }
 
-    /// Initialize execution context.
+    /// Initialize thread context.
     static void
-    init_exec_context(ExecContext *ec,
+    init_thread_context(ThreadContext *tc,
                       Tru64::nxm_thread_attr *attrp, uint64_t uniq_val)
     {
         using namespace TheISA;
 
-        ec->clearArchRegs();
+        tc->clearArchRegs();
 
-        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);
+        tc->setIntReg(TheISA::ArgumentReg0, gtoh(attrp->registers.a0));
+        tc->setIntReg(27/*t12*/, gtoh(attrp->registers.pc));
+        tc->setIntReg(TheISA::StackPointerReg, gtoh(attrp->registers.sp));
+        tc->setMiscReg(TheISA::Uniq_DepTag, uniq_val);
 
-        ec->setPC(gtoh(attrp->registers.pc));
-        ec->setNextPC(gtoh(attrp->registers.pc) + sizeof(TheISA::MachInst));
+        tc->setPC(gtoh(attrp->registers.pc));
+        tc->setNextPC(gtoh(attrp->registers.pc) + sizeof(TheISA::MachInst));
 
-        ec->activate();
+        tc->activate();
     }
 
     /// Create thread.
     static SyscallReturn
     nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process,
-                          ExecContext *xc)
+                          ThreadContext *tc)
     {
         using namespace std;
         using namespace TheISA;
 
-        TypedBufferArg<Tru64::nxm_thread_attr> attrp(xc->getSyscallArg(0));
-        TypedBufferArg<uint64_t> kidp(xc->getSyscallArg(1));
-        int thread_index = xc->getSyscallArg(2);
+        TypedBufferArg<Tru64::nxm_thread_attr> attrp(tc->getSyscallArg(0));
+        TypedBufferArg<uint64_t> kidp(tc->getSyscallArg(1));
+        int thread_index = tc->getSyscallArg(2);
 
         // get attribute args
-        attrp.copyIn(xc->getMemPort());
+        attrp.copyIn(tc->getMemPort());
 
         if (gtoh(attrp->version) != NXM_LIB_VERSION) {
             cerr << "nxm_thread_create: thread library version mismatch! "
@@ -872,7 +872,7 @@ class Tru64 {
 
         TypedBufferArg<Tru64::nxm_shared> rad_state(0x14000,
                                                     rad_state_size);
-        rad_state.copyIn(xc->getMemPort());
+        rad_state.copyIn(tc->getMemPort());
 
         uint64_t uniq_val = gtoh(attrp->pthid) - gtoh(rad_state->nxm_uniq_offset);
 
@@ -883,7 +883,7 @@ class Tru64 {
 
             // This is supposed to be a port number.  Make something up.
             *kidp = htog(99);
-            kidp.copyOut(xc->getMemPort());
+            kidp.copyOut(tc->getMemPort());
 
             return 0;
         } else if (gtoh(attrp->type) == Tru64::NXM_TYPE_VP) {
@@ -897,7 +897,7 @@ class Tru64 {
             ssp->nxm_u.pth_id = attrp->pthid;
             ssp->nxm_u.nxm_active = htog(uniq_val | 1);
 
-            rad_state.copyOut(xc->getMemPort());
+            rad_state.copyOut(tc->getMemPort());
 
             Addr slot_state_addr = 0x12000 + sizeof(Tru64::nxm_config_info);
             int slot_state_size =
@@ -907,7 +907,7 @@ class Tru64 {
                 slot_state(slot_state_addr,
                            slot_state_size);
 
-            slot_state.copyIn(xc->getMemPort());
+            slot_state.copyIn(tc->getMemPort());
 
             if (slot_state[thread_index] != Tru64::NXM_SLOT_AVAIL) {
                 cerr << "nxm_thread_createFunc: requested VP slot "
@@ -919,21 +919,21 @@ class Tru64 {
             // doesn't work anyway
             slot_state[thread_index] = Tru64::NXM_SLOT_BOUND;
 
-            slot_state.copyOut(xc->getMemPort());
+            slot_state.copyOut(tc->getMemPort());
 
-            // Find a free simulator execution context.
+            // Find a free simulator thread context.
             for (int i = 0; i < process->numCpus(); ++i) {
-                ExecContext *xc = process->execContexts[i];
+                ThreadContext *tc = process->threadContexts[i];
 
-                if (xc->status() == ExecContext::Suspended) {
+                if (tc->status() == ThreadContext::Suspended) {
                     // inactive context... grab it
-                    init_exec_context(xc, attrp, uniq_val);
+                    init_thread_context(tc, attrp, uniq_val);
 
                     // This is supposed to be a port number, but we'll try
                     // and get away with just sticking the thread index
                     // here.
                     *kidp = htog(thread_index);
-                    kidp.copyOut(xc->getMemPort());
+                    kidp.copyOut(tc->getMemPort());
 
                     return 0;
                 }
@@ -954,7 +954,7 @@ class Tru64 {
     /// Thread idle call (like yield()).
     static SyscallReturn
     nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process,
-                 ExecContext *xc)
+                 ThreadContext *tc)
     {
         return 0;
     }
@@ -962,17 +962,17 @@ class Tru64 {
     /// Block thread.
     static SyscallReturn
     nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process,
-                         ExecContext *xc)
+                         ThreadContext *tc)
     {
         using namespace std;
 
-        uint64_t tid = xc->getSyscallArg(0);
-        uint64_t secs = xc->getSyscallArg(1);
-        uint64_t flags = xc->getSyscallArg(2);
-        uint64_t action = xc->getSyscallArg(3);
-        uint64_t usecs = xc->getSyscallArg(4);
+        uint64_t tid = tc->getSyscallArg(0);
+        uint64_t secs = tc->getSyscallArg(1);
+        uint64_t flags = tc->getSyscallArg(2);
+        uint64_t action = tc->getSyscallArg(3);
+        uint64_t usecs = tc->getSyscallArg(4);
 
-        cout << xc->getCpuPtr()->name() << ": nxm_thread_block " << tid << " "
+        cout << tc->getCpuPtr()->name() << ": nxm_thread_block " << tid << " "
              << secs << " " << flags << " " << action << " " << usecs << endl;
 
         return 0;
@@ -981,17 +981,17 @@ class Tru64 {
     /// block.
     static SyscallReturn
     nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process,
-                  ExecContext *xc)
+                  ThreadContext *tc)
     {
         using namespace std;
 
-        Addr uaddr = xc->getSyscallArg(0);
-        uint64_t val = xc->getSyscallArg(1);
-        uint64_t secs = xc->getSyscallArg(2);
-        uint64_t usecs = xc->getSyscallArg(3);
-        uint64_t flags = xc->getSyscallArg(4);
+        Addr uaddr = tc->getSyscallArg(0);
+        uint64_t val = tc->getSyscallArg(1);
+        uint64_t secs = tc->getSyscallArg(2);
+        uint64_t usecs = tc->getSyscallArg(3);
+        uint64_t flags = tc->getSyscallArg(4);
 
-        BaseCPU *cpu = xc->getCpuPtr();
+        BaseCPU *cpu = tc->getCpuPtr();
 
         cout << cpu->name() << ": nxm_block "
              << hex << uaddr << dec << " " << val
@@ -1004,13 +1004,13 @@ class Tru64 {
     /// Unblock thread.
     static SyscallReturn
     nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process,
-                    ExecContext *xc)
+                    ThreadContext *tc)
     {
         using namespace std;
 
-        Addr uaddr = xc->getSyscallArg(0);
+        Addr uaddr = tc->getSyscallArg(0);
 
-        cout << xc->getCpuPtr()->name() << ": nxm_unblock "
+        cout << tc->getCpuPtr()->name() << ": nxm_unblock "
              << hex << uaddr << dec << endl;
 
         return 0;
@@ -1019,7 +1019,7 @@ class Tru64 {
     /// Switch thread priority.
     static SyscallReturn
     swtch_priFunc(SyscallDesc *desc, int callnum, Process *process,
-                  ExecContext *xc)
+                  ThreadContext *tc)
     {
         // Attempts to switch to another runnable thread (if there is
         // one).  Returns false if there are no other threads to run
@@ -1032,7 +1032,7 @@ class Tru64 {
     }
 
 
-    /// Activate exec context waiting on a channel.  Just activate one
+    /// Activate thread context waiting on a channel.  Just activate one
     /// by default.
     static int
     activate_waiting_context(Addr uaddr, Process *process,
@@ -1048,8 +1048,8 @@ class Tru64 {
         while (i != end && (num_activated == 0 || activate_all)) {
             if (i->waitChan == uaddr) {
                 // found waiting process: make it active
-                ExecContext *newCtx = i->waitingContext;
-                assert(newCtx->status() == ExecContext::Suspended);
+                ThreadContext *newCtx = i->waitingContext;
+                assert(newCtx->status() == ThreadContext::Suspended);
                 newCtx->activate();
 
                 // get rid of this record
@@ -1066,32 +1066,32 @@ class Tru64 {
 
     /// M5 hacked-up lock acquire.
     static void
-    m5_lock_mutex(Addr uaddr, Process *process, ExecContext *xc)
+    m5_lock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
     {
         using namespace TheISA;
 
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->getMemPort());
+        lockp.copyIn(tc->getMemPort());
 
         if (gtoh(*lockp) == 0) {
             // lock is free: grab it
             *lockp = htog(1);
-            lockp.copyOut(xc->getMemPort());
+            lockp.copyOut(tc->getMemPort());
         } else {
             // lock is busy: disable until free
-            process->waitList.push_back(Process::WaitRec(uaddr, xc));
-            xc->suspend();
+            process->waitList.push_back(Process::WaitRec(uaddr, tc));
+            tc->suspend();
         }
     }
 
     /// M5 unlock call.
     static void
-    m5_unlock_mutex(Addr uaddr, Process *process, ExecContext *xc)
+    m5_unlock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
     {
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->getMemPort());
+        lockp.copyIn(tc->getMemPort());
         assert(*lockp != 0);
 
         // Check for a process waiting on the lock.
@@ -1100,18 +1100,18 @@ class Tru64 {
         // clear lock field if no waiting context is taking over the lock
         if (num_waiting == 0) {
             *lockp = 0;
-            lockp.copyOut(xc->getMemPort());
+            lockp.copyOut(tc->getMemPort());
         }
     }
 
     /// Lock acquire syscall handler.
     static SyscallReturn
     m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process,
-                      ExecContext *xc)
+                      ThreadContext *tc)
     {
-        Addr uaddr = xc->getSyscallArg(0);
+        Addr uaddr = tc->getSyscallArg(0);
 
-        m5_lock_mutex(uaddr, process, xc);
+        m5_lock_mutex(uaddr, process, tc);
 
         // Return 0 since we will always return to the user with the lock
         // acquired.  We will just keep the context inactive until that is
@@ -1122,19 +1122,19 @@ class Tru64 {
     /// Try lock (non-blocking).
     static SyscallReturn
     m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process,
-                         ExecContext *xc)
+                         ThreadContext *tc)
     {
         using namespace TheISA;
 
-        Addr uaddr = xc->getSyscallArg(0);
+        Addr uaddr = tc->getSyscallArg(0);
         TypedBufferArg<uint64_t> lockp(uaddr);
 
-        lockp.copyIn(xc->getMemPort());
+        lockp.copyIn(tc->getMemPort());
 
         if (gtoh(*lockp) == 0) {
             // lock is free: grab it
             *lockp = htog(1);
-            lockp.copyOut(xc->getMemPort());
+            lockp.copyOut(tc->getMemPort());
             return 0;
         } else {
             return 1;
@@ -1144,11 +1144,11 @@ class Tru64 {
     /// Unlock syscall handler.
     static SyscallReturn
     m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process,
-                        ExecContext *xc)
+                        ThreadContext *tc)
     {
-        Addr uaddr = xc->getSyscallArg(0);
+        Addr uaddr = tc->getSyscallArg(0);
 
-        m5_unlock_mutex(uaddr, process, xc);
+        m5_unlock_mutex(uaddr, process, tc);
 
         return 0;
     }
@@ -1156,9 +1156,9 @@ class Tru64 {
     /// Signal ocndition.
     static SyscallReturn
     m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process,
-                       ExecContext *xc)
+                       ThreadContext *tc)
     {
-        Addr cond_addr = xc->getSyscallArg(0);
+        Addr cond_addr = tc->getSyscallArg(0);
 
         // Wake up one process waiting on the condition variable.
         activate_waiting_context(cond_addr, process);
@@ -1169,9 +1169,9 @@ class Tru64 {
     /// Wake up all processes waiting on the condition variable.
     static SyscallReturn
     m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process,
-                          ExecContext *xc)
+                          ThreadContext *tc)
     {
-        Addr cond_addr = xc->getSyscallArg(0);
+        Addr cond_addr = tc->getSyscallArg(0);
 
         activate_waiting_context(cond_addr, process, true);
 
@@ -1181,23 +1181,23 @@ class Tru64 {
     /// Wait on a condition.
     static SyscallReturn
     m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process,
-                     ExecContext *xc)
+                     ThreadContext *tc)
     {
         using namespace TheISA;
 
-        Addr cond_addr = xc->getSyscallArg(0);
-        Addr lock_addr = xc->getSyscallArg(1);
+        Addr cond_addr = tc->getSyscallArg(0);
+        Addr lock_addr = tc->getSyscallArg(1);
         TypedBufferArg<uint64_t> condp(cond_addr);
         TypedBufferArg<uint64_t> lockp(lock_addr);
 
         // user is supposed to acquire lock before entering
-        lockp.copyIn(xc->getMemPort());
+        lockp.copyIn(tc->getMemPort());
         assert(gtoh(*lockp) != 0);
 
-        m5_unlock_mutex(lock_addr, process, xc);
+        m5_unlock_mutex(lock_addr, process, tc);
 
-        process->waitList.push_back(Process::WaitRec(cond_addr, xc));
-        xc->suspend();
+        process->waitList.push_back(Process::WaitRec(cond_addr, tc));
+        tc->suspend();
 
         return 0;
     }
@@ -1205,10 +1205,10 @@ class Tru64 {
     /// Thread exit.
     static SyscallReturn
     m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process,
-                       ExecContext *xc)
+                       ThreadContext *tc)
     {
-        assert(xc->status() == ExecContext::Active);
-        xc->deallocate();
+        assert(tc->status() == ThreadContext::Active);
+        tc->deallocate();
 
         return 0;
     }
@@ -1216,21 +1216,21 @@ class Tru64 {
     /// Indirect syscall invocation (call #0).
     static SyscallReturn
     indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process,
-                        ExecContext *xc)
+                        ThreadContext *tc)
     {
-        int new_callnum = xc->getSyscallArg(0);
+        int new_callnum = tc->getSyscallArg(0);
         LiveProcess *lp = dynamic_cast<LiveProcess*>(process);
         assert(lp);
 
         for (int i = 0; i < 5; ++i)
-            xc->setSyscallArg(i, xc->getSyscallArg(i+1));
+            tc->setSyscallArg(i, tc->getSyscallArg(i+1));
 
 
         SyscallDesc *new_desc = lp->getDesc(new_callnum);
         if (desc == NULL)
             fatal("Syscall %d out of range", callnum);
 
-        new_desc->doSyscall(new_callnum, process, xc);
+        new_desc->doSyscall(new_callnum, process, tc);
 
         return 0;
     }
diff --git a/src/kern/tru64/tru64_events.cc b/src/kern/tru64/tru64_events.cc
index eb3f34836..69638bde1 100644
--- a/src/kern/tru64/tru64_events.cc
+++ b/src/kern/tru64/tru64_events.cc
@@ -29,7 +29,7 @@
  *          Lisa Hsu
  */
 
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "cpu/base.hh"
 #include "kern/system_events.hh"
 #include "kern/tru64/tru64_events.hh"
@@ -42,23 +42,23 @@
 
 using namespace TheISA;
 
-//void SkipFuncEvent::process(ExecContext *xc);
+//void SkipFuncEvent::process(ExecContext *tc);
 
 void
-BadAddrEvent::process(ExecContext *xc)
+BadAddrEvent::process(ThreadContext *tc)
 {
     // The following gross hack is the equivalent function to the
     // annotation for vmunix::badaddr in:
     // simos/simulation/apps/tcl/osf/tlaser.tcl
 
-    uint64_t a0 = xc->readIntReg(ArgumentReg0);
+    uint64_t a0 = tc->readIntReg(ArgumentReg0);
 
     AddrRangeList resp;
     AddrRangeList snoop;
     AddrRangeIter iter;
     bool found = false;
 
-    xc->getPhysPort()->getPeerAddressRanges(resp, snoop);
+    tc->getPhysPort()->getPeerAddressRanges(resp, snoop);
     for(iter = resp.begin(); iter != resp.end(); iter++)
     {
         if (*iter == (TheISA::K0Seg2Phys(a0) & EV5::PAddrImplMask))
@@ -68,41 +68,41 @@ BadAddrEvent::process(ExecContext *xc)
     if (!TheISA::IsK0Seg(a0) || found ) {
 
         DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
-        xc->setIntReg(ReturnValueReg, 0x1);
-        SkipFuncEvent::process(xc);
+        tc->setIntReg(ReturnValueReg, 0x1);
+        SkipFuncEvent::process(tc);
     }
     else
         DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
 }
 
 void
-PrintfEvent::process(ExecContext *xc)
+PrintfEvent::process(ThreadContext *tc)
 {
     if (DTRACE(Printf)) {
-        DebugOut() << curTick << ": " << xc->getCpuPtr()->name() << ": ";
+        DebugOut() << curTick << ": " << tc->getCpuPtr()->name() << ": ";
 
-        AlphaArguments args(xc);
+        AlphaArguments args(tc);
         tru64::Printf(args);
     }
 }
 
 void
-DebugPrintfEvent::process(ExecContext *xc)
+DebugPrintfEvent::process(ThreadContext *tc)
 {
     if (DTRACE(DebugPrintf)) {
         if (!raw)
-            DebugOut() << curTick << ": " << xc->getCpuPtr()->name() << ": ";
+            DebugOut() << curTick << ": " << tc->getCpuPtr()->name() << ": ";
 
-        AlphaArguments args(xc);
+        AlphaArguments args(tc);
         tru64::Printf(args);
     }
 }
 
 void
-DumpMbufEvent::process(ExecContext *xc)
+DumpMbufEvent::process(ThreadContext *tc)
 {
     if (DTRACE(DebugPrintf)) {
-        AlphaArguments args(xc);
+        AlphaArguments args(tc);
         tru64::DumpMbuf(args);
     }
 }
diff --git a/src/kern/tru64/tru64_events.hh b/src/kern/tru64/tru64_events.hh
index 6549d14a5..6a1ab2e51 100644
--- a/src/kern/tru64/tru64_events.hh
+++ b/src/kern/tru64/tru64_events.hh
@@ -37,14 +37,14 @@
 #include "cpu/pc_event.hh"
 #include "kern/system_events.hh"
 
-class ExecContext;
+class ThreadContext;
 
 class BadAddrEvent : public SkipFuncEvent
 {
   public:
     BadAddrEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : SkipFuncEvent(q, desc, addr) {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class PrintfEvent : public PCEvent
@@ -52,7 +52,7 @@ class PrintfEvent : public PCEvent
   public:
     PrintfEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr) {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class DebugPrintfEvent : public PCEvent
@@ -64,7 +64,7 @@ class DebugPrintfEvent : public PCEvent
     DebugPrintfEvent(PCEventQueue *q, const std::string &desc, Addr addr,
                      bool r = false)
         : PCEvent(q, desc, addr), raw(r) {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 class DebugPrintfrEvent : public DebugPrintfEvent
@@ -80,7 +80,7 @@ class DumpMbufEvent : public PCEvent
   public:
     DumpMbufEvent(PCEventQueue *q, const std::string &desc, Addr addr)
         : PCEvent(q, desc, addr) {}
-    virtual void process(ExecContext *xc);
+    virtual void process(ThreadContext *tc);
 };
 
 #endif // __TRU64_EVENTS_HH__