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

1 files changed, 111 insertions, 111 deletions

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;
     }