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

11 files changed, 307 insertions, 307 deletions

diff --git a/src/sim/faults.cc b/src/sim/faults.cc
index 6a598a3f4..650b728f7 100644
--- a/src/sim/faults.cc
+++ b/src/sim/faults.cc
@@ -31,25 +31,25 @@
 
 #include "base/misc.hh"
 #include "sim/faults.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "cpu/base.hh"
 
 #if !FULL_SYSTEM
-void FaultBase::invoke(ExecContext * xc)
+void FaultBase::invoke(ThreadContext * tc)
 {
-    fatal("fault (%s) detected @ PC 0x%08p", name(), xc->readPC());
+    fatal("fault (%s) detected @ PC 0x%08p", name(), tc->readPC());
 }
 #else
-void FaultBase::invoke(ExecContext * xc)
+void FaultBase::invoke(ThreadContext * tc)
 {
-    DPRINTF(Fault, "Fault %s at PC: %#x\n", name(), xc->readPC());
-    xc->getCpuPtr()->recordEvent(csprintf("Fault %s", name()));
+    DPRINTF(Fault, "Fault %s at PC: %#x\n", name(), tc->readPC());
+    tc->getCpuPtr()->recordEvent(csprintf("Fault %s", name()));
 
-    assert(!xc->misspeculating());
+    assert(!tc->misspeculating());
 }
 #endif
 
-void UnimpFault::invoke(ExecContext * xc)
+void UnimpFault::invoke(ThreadContext * tc)
 {
     panic("Unimpfault: %s\n", panicStr.c_str());
 }
diff --git a/src/sim/faults.hh b/src/sim/faults.hh
index 7da69a916..23385c649 100644
--- a/src/sim/faults.hh
+++ b/src/sim/faults.hh
@@ -36,7 +36,7 @@
 #include "sim/stats.hh"
 #include "config/full_system.hh"
 
-class ExecContext;
+class ThreadContext;
 class FaultBase;
 typedef RefCountingPtr<FaultBase> Fault;
 
@@ -55,9 +55,9 @@ class FaultBase : public RefCounted
   public:
     virtual FaultName name() = 0;
 #if FULL_SYSTEM
-    virtual void invoke(ExecContext * xc);
+    virtual void invoke(ThreadContext * tc);
 #else
-    virtual void invoke(ExecContext * xc);
+    virtual void invoke(ThreadContext * tc);
 #endif
 //    template<typename T>
 //    bool isA() {return dynamic_cast<T *>(this);}
@@ -77,7 +77,7 @@ class UnimpFault : public FaultBase
     { }
 
     FaultName name() {return "Unimplemented simulator feature";}
-    void invoke(ExecContext * xc);
+    void invoke(ThreadContext * tc);
 };
 
 #endif // __FAULTS_HH__
diff --git a/src/sim/process.cc b/src/sim/process.cc
index e8a5284d4..1533a376d 100644
--- a/src/sim/process.cc
+++ b/src/sim/process.cc
@@ -40,7 +40,7 @@
 #include "base/loader/symtab.hh"
 #include "base/statistics.hh"
 #include "config/full_system.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "mem/page_table.hh"
 #include "mem/physical.hh"
 #include "mem/translating_port.hh"
@@ -134,11 +134,11 @@ Process::openOutputFile(const string &filename)
 
 
 int
-Process::registerExecContext(ExecContext *xc)
+Process::registerThreadContext(ThreadContext *tc)
 {
     // add to list
-    int myIndex = execContexts.size();
-    execContexts.push_back(xc);
+    int myIndex = threadContexts.size();
+    threadContexts.push_back(tc);
 
     // return CPU number to caller
     return myIndex;
@@ -147,14 +147,14 @@ Process::registerExecContext(ExecContext *xc)
 void
 Process::startup()
 {
-    if (execContexts.empty())
+    if (threadContexts.empty())
         fatal("Process %s is not associated with any CPUs!\n", name());
 
-    // first exec context for this process... initialize & enable
-    ExecContext *xc = execContexts[0];
+    // first thread context for this process... initialize & enable
+    ThreadContext *tc = threadContexts[0];
 
     // mark this context as active so it will start ticking.
-    xc->activate(0);
+    tc->activate(0);
 
     Port *mem_port;
     mem_port = system->physmem->getPort("functional");
@@ -164,14 +164,14 @@ Process::startup()
 }
 
 void
-Process::replaceExecContext(ExecContext *xc, int xcIndex)
+Process::replaceThreadContext(ThreadContext *tc, int tcIndex)
 {
-    if (xcIndex >= execContexts.size()) {
-        panic("replaceExecContext: bad xcIndex, %d >= %d\n",
-              xcIndex, execContexts.size());
+    if (tcIndex >= threadContexts.size()) {
+        panic("replaceThreadContext: bad tcIndex, %d >= %d\n",
+              tcIndex, threadContexts.size());
     }
 
-    execContexts[xcIndex] = xc;
+    threadContexts[tcIndex] = tc;
 }
 
 // map simulator fd sim_fd to target fd tgt_fd
@@ -338,20 +338,20 @@ LiveProcess::argsInit(int intSize, int pageSize)
     copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
     copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
 
-    execContexts[0]->setIntReg(ArgumentReg0, argc);
-    execContexts[0]->setIntReg(ArgumentReg1, argv_array_base);
-    execContexts[0]->setIntReg(StackPointerReg, stack_min);
+    threadContexts[0]->setIntReg(ArgumentReg0, argc);
+    threadContexts[0]->setIntReg(ArgumentReg1, argv_array_base);
+    threadContexts[0]->setIntReg(StackPointerReg, stack_min);
 
     Addr prog_entry = objFile->entryPoint();
-    execContexts[0]->setPC(prog_entry);
-    execContexts[0]->setNextPC(prog_entry + sizeof(MachInst));
-    execContexts[0]->setNextNPC(prog_entry + (2 * sizeof(MachInst)));
+    threadContexts[0]->setPC(prog_entry);
+    threadContexts[0]->setNextPC(prog_entry + sizeof(MachInst));
+    threadContexts[0]->setNextNPC(prog_entry + (2 * sizeof(MachInst)));
 
     num_processes++;
 }
 
 void
-LiveProcess::syscall(int64_t callnum, ExecContext *xc)
+LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
 {
     num_syscalls++;
 
@@ -359,7 +359,7 @@ LiveProcess::syscall(int64_t callnum, ExecContext *xc)
     if (desc == NULL)
         fatal("Syscall %d out of range", callnum);
 
-    desc->doSyscall(callnum, this, xc);
+    desc->doSyscall(callnum, this, tc);
 }
 
 DEFINE_SIM_OBJECT_CLASS_NAME("LiveProcess", LiveProcess);
diff --git a/src/sim/process.hh b/src/sim/process.hh
index d50c937be..15d564455 100644
--- a/src/sim/process.hh
+++ b/src/sim/process.hh
@@ -47,7 +47,7 @@
 #include "sim/sim_object.hh"
 
 class CPUExecContext;
-class ExecContext;
+class ThreadContext;
 class SyscallDesc;
 class PageTable;
 class TranslatingPort;
@@ -65,24 +65,24 @@ class Process : public SimObject
     /// running on.
     System *system;
 
-    // have we initialized an execution context from this process?  If
+    // have we initialized a thread context from this process?  If
     // yes, subsequent contexts are assumed to be for dynamically
     // created threads and are not initialized.
     bool initialContextLoaded;
 
-    // execution contexts associated with this process
-    std::vector<ExecContext *> execContexts;
+    // thread contexts associated with this process
+    std::vector<ThreadContext *> threadContexts;
 
     // number of CPUs (esxec contexts, really) assigned to this process.
-    unsigned int numCpus() { return execContexts.size(); }
+    unsigned int numCpus() { return threadContexts.size(); }
 
     // record of blocked context
     struct WaitRec
     {
         Addr waitChan;
-        ExecContext *waitingContext;
+        ThreadContext *waitingContext;
 
-        WaitRec(Addr chan, ExecContext *ctx)
+        WaitRec(Addr chan, ThreadContext *ctx)
             : waitChan(chan), waitingContext(ctx)
         {	}
     };
@@ -143,12 +143,12 @@ class Process : public SimObject
     // override of virtual SimObject method: register statistics
     virtual void regStats();
 
-    // register an execution context for this process.
-    // returns xc's cpu number (index into execContexts[])
-    int registerExecContext(ExecContext *xc);
+    // register a thread context for this process.
+    // returns tc's cpu number (index into threadContexts[])
+    int registerThreadContext(ThreadContext *tc);
 
 
-    void replaceExecContext(ExecContext *xc, int xcIndex);
+    void replaceThreadContext(ThreadContext *tc, int tcIndex);
 
     // map simulator fd sim_fd to target fd tgt_fd
     void dup_fd(int sim_fd, int tgt_fd);
@@ -162,7 +162,7 @@ class Process : public SimObject
     // look up simulator fd for given target fd
     int sim_fd(int tgt_fd);
 
-    virtual void syscall(int64_t callnum, ExecContext *xc) = 0;
+    virtual void syscall(int64_t callnum, ThreadContext *tc) = 0;
 };
 
 //
@@ -184,7 +184,7 @@ class LiveProcess : public Process
     virtual void argsInit(int intSize, int pageSize);
 
   public:
-    virtual void syscall(int64_t callnum, ExecContext *xc);
+    virtual void syscall(int64_t callnum, ThreadContext *tc);
 
     virtual SyscallDesc* getDesc(int callnum) = 0;
 };
diff --git a/src/sim/pseudo_inst.cc b/src/sim/pseudo_inst.cc
index 8ad298454..50d949f53 100644
--- a/src/sim/pseudo_inst.cc
+++ b/src/sim/pseudo_inst.cc
@@ -38,7 +38,7 @@
 #include "arch/vtophys.hh"
 #include "cpu/base.hh"
 #include "cpu/sampler/sampler.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "cpu/quiesce_event.hh"
 #include "kern/kernel_stats.hh"
 #include "sim/param.hh"
@@ -64,94 +64,94 @@ namespace AlphaPseudo
     bool doQuiesce;
 
     void
-    arm(ExecContext *xc)
+    arm(ThreadContext *tc)
     {
-        if (xc->getKernelStats())
-            xc->getKernelStats()->arm();
+        if (tc->getKernelStats())
+            tc->getKernelStats()->arm();
     }
 
     void
-    quiesce(ExecContext *xc)
+    quiesce(ThreadContext *tc)
     {
         if (!doQuiesce)
             return;
 
-        xc->suspend();
-        if (xc->getKernelStats())
-            xc->getKernelStats()->quiesce();
+        tc->suspend();
+        if (tc->getKernelStats())
+            tc->getKernelStats()->quiesce();
     }
 
     void
-    quiesceNs(ExecContext *xc, uint64_t ns)
+    quiesceNs(ThreadContext *tc, uint64_t ns)
     {
         if (!doQuiesce || ns == 0)
             return;
 
-        EndQuiesceEvent *quiesceEvent = xc->getQuiesceEvent();
+        EndQuiesceEvent *quiesceEvent = tc->getQuiesceEvent();
 
         if (quiesceEvent->scheduled())
             quiesceEvent->reschedule(curTick + Clock::Int::ns * ns);
         else
             quiesceEvent->schedule(curTick + Clock::Int::ns * ns);
 
-        xc->suspend();
-        if (xc->getKernelStats())
-            xc->getKernelStats()->quiesce();
+        tc->suspend();
+        if (tc->getKernelStats())
+            tc->getKernelStats()->quiesce();
     }
 
     void
-    quiesceCycles(ExecContext *xc, uint64_t cycles)
+    quiesceCycles(ThreadContext *tc, uint64_t cycles)
     {
         if (!doQuiesce || cycles == 0)
             return;
 
-        EndQuiesceEvent *quiesceEvent = xc->getQuiesceEvent();
+        EndQuiesceEvent *quiesceEvent = tc->getQuiesceEvent();
 
         if (quiesceEvent->scheduled())
             quiesceEvent->reschedule(curTick +
-                                     xc->getCpuPtr()->cycles(cycles));
+                                     tc->getCpuPtr()->cycles(cycles));
         else
             quiesceEvent->schedule(curTick +
-                                   xc->getCpuPtr()->cycles(cycles));
+                                   tc->getCpuPtr()->cycles(cycles));
 
-        xc->suspend();
-        if (xc->getKernelStats())
-            xc->getKernelStats()->quiesce();
+        tc->suspend();
+        if (tc->getKernelStats())
+            tc->getKernelStats()->quiesce();
     }
 
     uint64_t
-    quiesceTime(ExecContext *xc)
+    quiesceTime(ThreadContext *tc)
     {
-        return (xc->readLastActivate() - xc->readLastSuspend()) / Clock::Int::ns;
+        return (tc->readLastActivate() - tc->readLastSuspend()) / Clock::Int::ns;
     }
 
     void
-    ivlb(ExecContext *xc)
+    ivlb(ThreadContext *tc)
     {
-        if (xc->getKernelStats())
-            xc->getKernelStats()->ivlb();
+        if (tc->getKernelStats())
+            tc->getKernelStats()->ivlb();
     }
 
     void
-    ivle(ExecContext *xc)
+    ivle(ThreadContext *tc)
     {
     }
 
     void
-    m5exit_old(ExecContext *xc)
+    m5exit_old(ThreadContext *tc)
     {
         SimExit(curTick, "m5_exit_old instruction encountered");
     }
 
     void
-    m5exit(ExecContext *xc, Tick delay)
+    m5exit(ThreadContext *tc, Tick delay)
     {
         Tick when = curTick + delay * Clock::Int::ns;
         SimExit(when, "m5_exit instruction encountered");
     }
 
     void
-    resetstats(ExecContext *xc, Tick delay, Tick period)
+    resetstats(ThreadContext *tc, Tick delay, Tick period)
     {
         if (!doStatisticsInsts)
             return;
@@ -165,7 +165,7 @@ namespace AlphaPseudo
     }
 
     void
-    dumpstats(ExecContext *xc, Tick delay, Tick period)
+    dumpstats(ThreadContext *tc, Tick delay, Tick period)
     {
         if (!doStatisticsInsts)
             return;
@@ -179,19 +179,19 @@ namespace AlphaPseudo
     }
 
     void
-    addsymbol(ExecContext *xc, Addr addr, Addr symbolAddr)
+    addsymbol(ThreadContext *tc, Addr addr, Addr symbolAddr)
     {
         char symb[100];
-        CopyStringOut(xc, symb, symbolAddr, 100);
+        CopyStringOut(tc, symb, symbolAddr, 100);
         std::string symbol(symb);
 
         DPRINTF(Loader, "Loaded symbol: %s @ %#llx\n", symbol, addr);
 
-        xc->getSystemPtr()->kernelSymtab->insert(addr,symbol);
+        tc->getSystemPtr()->kernelSymtab->insert(addr,symbol);
     }
 
     void
-    dumpresetstats(ExecContext *xc, Tick delay, Tick period)
+    dumpresetstats(ThreadContext *tc, Tick delay, Tick period)
     {
         if (!doStatisticsInsts)
             return;
@@ -205,7 +205,7 @@ namespace AlphaPseudo
     }
 
     void
-    m5checkpoint(ExecContext *xc, Tick delay, Tick period)
+    m5checkpoint(ThreadContext *tc, Tick delay, Tick period)
     {
         if (!doCheckpointInsts)
             return;
@@ -218,9 +218,9 @@ namespace AlphaPseudo
     }
 
     uint64_t
-    readfile(ExecContext *xc, Addr vaddr, uint64_t len, uint64_t offset)
+    readfile(ThreadContext *tc, Addr vaddr, uint64_t len, uint64_t offset)
     {
-        const string &file = xc->getCpuPtr()->system->params()->readfile;
+        const string &file = tc->getCpuPtr()->system->params()->readfile;
         if (file.empty()) {
             return ULL(0);
         }
@@ -247,7 +247,7 @@ namespace AlphaPseudo
         }
 
         close(fd);
-        CopyIn(xc, vaddr, buf, result);
+        CopyIn(tc, vaddr, buf, result);
         delete [] buf;
         return result;
     }
@@ -279,12 +279,12 @@ namespace AlphaPseudo
         doCheckpointInsts = __checkpoint;
     }
 
-    void debugbreak(ExecContext *xc)
+    void debugbreak(ThreadContext *tc)
     {
         debug_break();
     }
 
-    void switchcpu(ExecContext *xc)
+    void switchcpu(ThreadContext *tc)
     {
         if (SampCPU)
             SampCPU->switchCPUs();
diff --git a/src/sim/pseudo_inst.hh b/src/sim/pseudo_inst.hh
index 2252964cd..5e5b7d95f 100644
--- a/src/sim/pseudo_inst.hh
+++ b/src/sim/pseudo_inst.hh
@@ -28,7 +28,7 @@
  * Authors: Nathan Binkert
  */
 
-class ExecContext;
+class ThreadContext;
 
 //We need the "Tick" data type from here
 #include "sim/host.hh"
@@ -44,21 +44,21 @@ namespace AlphaPseudo
     extern bool doCheckpointInsts;
     extern bool doQuiesce;
 
-    void arm(ExecContext *xc);
-    void quiesce(ExecContext *xc);
-    void quiesceNs(ExecContext *xc, uint64_t ns);
-    void quiesceCycles(ExecContext *xc, uint64_t cycles);
-    uint64_t quiesceTime(ExecContext *xc);
-    void ivlb(ExecContext *xc);
-    void ivle(ExecContext *xc);
-    void m5exit(ExecContext *xc, Tick delay);
-    void m5exit_old(ExecContext *xc);
-    void resetstats(ExecContext *xc, Tick delay, Tick period);
-    void dumpstats(ExecContext *xc, Tick delay, Tick period);
-    void dumpresetstats(ExecContext *xc, Tick delay, Tick period);
-    void m5checkpoint(ExecContext *xc, Tick delay, Tick period);
-    uint64_t readfile(ExecContext *xc, Addr vaddr, uint64_t len, uint64_t offset);
-    void debugbreak(ExecContext *xc);
-    void switchcpu(ExecContext *xc);
-    void addsymbol(ExecContext *xc, Addr addr, Addr symbolAddr);
+    void arm(ThreadContext *tc);
+    void quiesce(ThreadContext *tc);
+    void quiesceNs(ThreadContext *tc, uint64_t ns);
+    void quiesceCycles(ThreadContext *tc, uint64_t cycles);
+    uint64_t quiesceTime(ThreadContext *tc);
+    void ivlb(ThreadContext *tc);
+    void ivle(ThreadContext *tc);
+    void m5exit(ThreadContext *tc, Tick delay);
+    void m5exit_old(ThreadContext *tc);
+    void resetstats(ThreadContext *tc, Tick delay, Tick period);
+    void dumpstats(ThreadContext *tc, Tick delay, Tick period);
+    void dumpresetstats(ThreadContext *tc, Tick delay, Tick period);
+    void m5checkpoint(ThreadContext *tc, Tick delay, Tick period);
+    uint64_t readfile(ThreadContext *tc, Addr vaddr, uint64_t len, uint64_t offset);
+    void debugbreak(ThreadContext *tc);
+    void switchcpu(ThreadContext *tc);
+    void addsymbol(ThreadContext *tc, Addr addr, Addr symbolAddr);
 }
diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc
index e37fea1b1..888c133c0 100644
--- a/src/sim/syscall_emul.cc
+++ b/src/sim/syscall_emul.cc
@@ -38,7 +38,7 @@
 #include "sim/syscall_emul.hh"
 #include "base/chunk_generator.hh"
 #include "base/trace.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "cpu/base.hh"
 #include "mem/page_table.hh"
 #include "sim/process.hh"
@@ -49,26 +49,26 @@ using namespace std;
 using namespace TheISA;
 
 void
-SyscallDesc::doSyscall(int callnum, Process *process, ExecContext *xc)
+SyscallDesc::doSyscall(int callnum, Process *process, ThreadContext *tc)
 {
     DPRINTFR(SyscallVerbose, "%d: %s: syscall %s called w/arguments %d,%d,%d,%d\n",
-             curTick,xc->getCpuPtr()->name(), name,
-             xc->getSyscallArg(0),xc->getSyscallArg(1),
-             xc->getSyscallArg(2),xc->getSyscallArg(3));
+             curTick,tc->getCpuPtr()->name(), name,
+             tc->getSyscallArg(0),tc->getSyscallArg(1),
+             tc->getSyscallArg(2),tc->getSyscallArg(3));
 
-    SyscallReturn retval = (*funcPtr)(this, callnum, process, xc);
+    SyscallReturn retval = (*funcPtr)(this, callnum, process, tc);
 
     DPRINTFR(SyscallVerbose, "%d: %s: syscall %s returns %d\n",
-             curTick,xc->getCpuPtr()->name(), name, retval.value());
+             curTick,tc->getCpuPtr()->name(), name, retval.value());
 
     if (!(flags & SyscallDesc::SuppressReturnValue))
-        xc->setSyscallReturn(retval);
+        tc->setSyscallReturn(retval);
 }
 
 
 SyscallReturn
 unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
-                  ExecContext *xc)
+                  ThreadContext *tc)
 {
     fatal("syscall %s (#%d) unimplemented.", desc->name, callnum);
 
@@ -78,10 +78,10 @@ unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
 
 SyscallReturn
 ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     warn("ignoring syscall %s(%d, %d, ...)", desc->name,
-         xc->getSyscallArg(0), xc->getSyscallArg(1));
+         tc->getSyscallArg(0), tc->getSyscallArg(1));
 
     return 0;
 }
@@ -89,28 +89,28 @@ ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
 
 SyscallReturn
 exitFunc(SyscallDesc *desc, int callnum, Process *process,
-         ExecContext *xc)
+         ThreadContext *tc)
 {
-    new SimExitEvent("target called exit()", xc->getSyscallArg(0) & 0xff);
+    new SimExitEvent("target called exit()", tc->getSyscallArg(0) & 0xff);
 
     return 1;
 }
 
 
 SyscallReturn
-getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     return (int)VMPageSize;
 }
 
 
 SyscallReturn
-obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+obreakFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     Addr junk;
 
     // change brk addr to first arg
-    Addr new_brk = xc->getSyscallArg(0);
+    Addr new_brk = tc->getSyscallArg(0);
     if (new_brk != 0) {
         for (ChunkGenerator gen(p->brk_point, new_brk - p->brk_point,
                                 VMPageSize); !gen.done(); gen.next()) {
@@ -126,9 +126,9 @@ obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 
 
 SyscallReturn
-closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+closeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    int target_fd = xc->getSyscallArg(0);
+    int target_fd = tc->getSyscallArg(0);
     int status = close(p->sim_fd(target_fd));
     if (status >= 0)
         p->free_fd(target_fd);
@@ -137,28 +137,28 @@ closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 
 
 SyscallReturn
-readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+readFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    int fd = p->sim_fd(xc->getSyscallArg(0));
-    int nbytes = xc->getSyscallArg(2);
-    BufferArg bufArg(xc->getSyscallArg(1), nbytes);
+    int fd = p->sim_fd(tc->getSyscallArg(0));
+    int nbytes = tc->getSyscallArg(2);
+    BufferArg bufArg(tc->getSyscallArg(1), nbytes);
 
     int bytes_read = read(fd, bufArg.bufferPtr(), nbytes);
 
     if (bytes_read != -1)
-        bufArg.copyOut(xc->getMemPort());
+        bufArg.copyOut(tc->getMemPort());
 
     return bytes_read;
 }
 
 SyscallReturn
-writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+writeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    int fd = p->sim_fd(xc->getSyscallArg(0));
-    int nbytes = xc->getSyscallArg(2);
-    BufferArg bufArg(xc->getSyscallArg(1), nbytes);
+    int fd = p->sim_fd(tc->getSyscallArg(0));
+    int nbytes = tc->getSyscallArg(2);
+    BufferArg bufArg(tc->getSyscallArg(1), nbytes);
 
-    bufArg.copyIn(xc->getMemPort());
+    bufArg.copyIn(tc->getMemPort());
 
     int bytes_written = write(fd, bufArg.bufferPtr(), nbytes);
 
@@ -169,11 +169,11 @@ writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 
 
 SyscallReturn
-lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+lseekFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    int fd = p->sim_fd(xc->getSyscallArg(0));
-    uint64_t offs = xc->getSyscallArg(1);
-    int whence = xc->getSyscallArg(2);
+    int fd = p->sim_fd(tc->getSyscallArg(0));
+    uint64_t offs = tc->getSyscallArg(1);
+    int whence = tc->getSyscallArg(2);
 
     off_t result = lseek(fd, offs, whence);
 
@@ -182,7 +182,7 @@ lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 
 
 SyscallReturn
-munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+munmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     // given that we don't really implement mmap, munmap is really easy
     return 0;
@@ -192,24 +192,24 @@ munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 const char *hostname = "m5.eecs.umich.edu";
 
 SyscallReturn
-gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+gethostnameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    int name_len = xc->getSyscallArg(1);
-    BufferArg name(xc->getSyscallArg(0), name_len);
+    int name_len = tc->getSyscallArg(1);
+    BufferArg name(tc->getSyscallArg(0), name_len);
 
     strncpy((char *)name.bufferPtr(), hostname, name_len);
 
-    name.copyOut(xc->getMemPort());
+    name.copyOut(tc->getMemPort());
 
     return 0;
 }
 
 SyscallReturn
-unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+unlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
         return (TheISA::IntReg)-EFAULT;
 
     int result = unlink(path.c_str());
@@ -217,16 +217,16 @@ unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 }
 
 SyscallReturn
-renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+renameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string old_name;
 
-    if (!xc->getMemPort()->tryReadString(old_name, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(old_name, tc->getSyscallArg(0)))
         return -EFAULT;
 
     string new_name;
 
-    if (!xc->getMemPort()->tryReadString(new_name, xc->getSyscallArg(1)))
+    if (!tc->getMemPort()->tryReadString(new_name, tc->getSyscallArg(1)))
         return -EFAULT;
 
     int64_t result = rename(old_name.c_str(), new_name.c_str());
@@ -234,45 +234,45 @@ renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 }
 
 SyscallReturn
-truncateFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+truncateFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
         return -EFAULT;
 
-    off_t length = xc->getSyscallArg(1);
+    off_t length = tc->getSyscallArg(1);
 
     int result = truncate(path.c_str(), length);
     return (result == -1) ? -errno : result;
 }
 
 SyscallReturn
-ftruncateFunc(SyscallDesc *desc, int num, Process *process, ExecContext *xc)
+ftruncateFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 {
-    int fd = process->sim_fd(xc->getSyscallArg(0));
+    int fd = process->sim_fd(tc->getSyscallArg(0));
 
     if (fd < 0)
         return -EBADF;
 
-    off_t length = xc->getSyscallArg(1);
+    off_t length = tc->getSyscallArg(1);
 
     int result = ftruncate(fd, length);
     return (result == -1) ? -errno : result;
 }
 
 SyscallReturn
-chownFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+chownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
         return -EFAULT;
 
     /* XXX endianess */
-    uint32_t owner = xc->getSyscallArg(1);
+    uint32_t owner = tc->getSyscallArg(1);
     uid_t hostOwner = owner;
-    uint32_t group = xc->getSyscallArg(2);
+    uint32_t group = tc->getSyscallArg(2);
     gid_t hostGroup = group;
 
     int result = chown(path.c_str(), hostOwner, hostGroup);
@@ -280,17 +280,17 @@ chownFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 }
 
 SyscallReturn
-fchownFunc(SyscallDesc *desc, int num, Process *process, ExecContext *xc)
+fchownFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 {
-    int fd = process->sim_fd(xc->getSyscallArg(0));
+    int fd = process->sim_fd(tc->getSyscallArg(0));
 
     if (fd < 0)
         return -EBADF;
 
     /* XXX endianess */
-    uint32_t owner = xc->getSyscallArg(1);
+    uint32_t owner = tc->getSyscallArg(1);
     uid_t hostOwner = owner;
-    uint32_t group = xc->getSyscallArg(2);
+    uint32_t group = tc->getSyscallArg(2);
     gid_t hostGroup = group;
 
     int result = fchown(fd, hostOwner, hostGroup);
@@ -300,14 +300,14 @@ fchownFunc(SyscallDesc *desc, int num, Process *process, ExecContext *xc)
 
 SyscallReturn
 fcntlFunc(SyscallDesc *desc, int num, Process *process,
-          ExecContext *xc)
+          ThreadContext *tc)
 {
-    int fd = xc->getSyscallArg(0);
+    int fd = tc->getSyscallArg(0);
 
     if (fd < 0 || process->sim_fd(fd) < 0)
         return -EBADF;
 
-    int cmd = xc->getSyscallArg(1);
+    int cmd = tc->getSyscallArg(1);
     switch (cmd) {
       case 0: // F_DUPFD
         // if we really wanted to support this, we'd need to do it
@@ -342,7 +342,7 @@ fcntlFunc(SyscallDesc *desc, int num, Process *process,
 
 SyscallReturn
 pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
-         ExecContext *xc)
+         ThreadContext *tc)
 {
     int fds[2], sim_fds[2];
     int pipe_retval = pipe(fds);
@@ -357,99 +357,99 @@ pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
 
     // Alpha Linux convention for pipe() is that fd[0] is returned as
     // the return value of the function, and fd[1] is returned in r20.
-    xc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
+    tc->setIntReg(SyscallPseudoReturnReg, sim_fds[1]);
     return sim_fds[0];
 }
 
 
 SyscallReturn
 getpidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     // Make up a PID.  There's no interprocess communication in
     // fake_syscall mode, so there's no way for a process to know it's
     // not getting a unique value.
 
-    xc->setIntReg(SyscallPseudoReturnReg, 99);
+    tc->setIntReg(SyscallPseudoReturnReg, 99);
     return 100;
 }
 
 
 SyscallReturn
 getuidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     // Make up a UID and EUID... it shouldn't matter, and we want the
     // simulation to be deterministic.
 
     // EUID goes in r20.
-    xc->setIntReg(SyscallPseudoReturnReg, 100); //EUID
+    tc->setIntReg(SyscallPseudoReturnReg, 100); //EUID
     return 100;		// UID
 }
 
 
 SyscallReturn
 getgidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     // Get current group ID.  EGID goes in r20.
-    xc->setIntReg(SyscallPseudoReturnReg, 100); //EGID
+    tc->setIntReg(SyscallPseudoReturnReg, 100); //EGID
     return 100;
 }
 
 
 SyscallReturn
 setuidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     // can't fathom why a benchmark would call this.
-    warn("Ignoring call to setuid(%d)\n", xc->getSyscallArg(0));
+    warn("Ignoring call to setuid(%d)\n", tc->getSyscallArg(0));
     return 0;
 }
 
 SyscallReturn
 getpidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     // Make up a PID.  There's no interprocess communication in
     // fake_syscall mode, so there's no way for a process to know it's
     // not getting a unique value.
 
-    xc->setIntReg(SyscallPseudoReturnReg, 99); //PID
+    tc->setIntReg(SyscallPseudoReturnReg, 99); //PID
     return 100;
 }
 
 SyscallReturn
 getppidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     return 99;
 }
 
 SyscallReturn
 getuidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     return 100;		// UID
 }
 
 SyscallReturn
 geteuidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     return 100;		// UID
 }
 
 SyscallReturn
 getgidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     return 100;
 }
 
 SyscallReturn
 getegidFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     return 100;
 }
diff --git a/src/sim/syscall_emul.hh b/src/sim/syscall_emul.hh
index b21e299e9..874eaf6a4 100644
--- a/src/sim/syscall_emul.hh
+++ b/src/sim/syscall_emul.hh
@@ -54,7 +54,7 @@
 #include "base/misc.hh"
 #include "base/trace.hh"
 #include "cpu/base.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "mem/translating_port.hh"
 #include "mem/page_table.hh"
 #include "sim/process.hh"
@@ -68,7 +68,7 @@ class SyscallDesc {
 
     /// Typedef for target syscall handler functions.
     typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num,
-                           Process *, ExecContext *);
+                           Process *, ThreadContext *);
 
     const char *name;	//!< Syscall name (e.g., "open").
     FuncPtr funcPtr;	//!< Pointer to emulation function.
@@ -78,7 +78,7 @@ class SyscallDesc {
     enum Flags {
         /// Don't set return regs according to funcPtr return value.
         /// Used for syscalls with non-standard return conventions
-        /// that explicitly set the ExecContext regs (e.g.,
+        /// that explicitly set the ThreadContext regs (e.g.,
         /// sigreturn).
         SuppressReturnValue = 1
     };
@@ -90,7 +90,7 @@ class SyscallDesc {
     }
 
     /// Emulate the syscall.  Public interface for calling through funcPtr.
-    void doSyscall(int callnum, Process *proc, ExecContext *xc);
+    void doSyscall(int callnum, Process *proc, ThreadContext *tc);
 };
 
 
@@ -172,129 +172,129 @@ class TypedBufferArg : public BaseBufferArg
 
 /// Handler for unimplemented syscalls that we haven't thought about.
 SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
-                                Process *p, ExecContext *xc);
+                                Process *p, ThreadContext *tc);
 
 /// Handler for unimplemented syscalls that we never intend to
 /// implement (signal handling, etc.) and should not affect the correct
 /// behavior of the program.  Print a warning only if the appropriate
 /// trace flag is enabled.  Return success to the target program.
 SyscallReturn ignoreFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 /// Target exit() handler: terminate simulation.
 SyscallReturn exitFunc(SyscallDesc *desc, int num,
-                       Process *p, ExecContext *xc);
+                       Process *p, ThreadContext *tc);
 
 /// Target getpagesize() handler.
 SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
-                              Process *p, ExecContext *xc);
+                              Process *p, ThreadContext *tc);
 
 /// Target obreak() handler: set brk address.
 SyscallReturn obreakFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 /// Target close() handler.
 SyscallReturn closeFunc(SyscallDesc *desc, int num,
-                        Process *p, ExecContext *xc);
+                        Process *p, ThreadContext *tc);
 
 /// Target read() handler.
 SyscallReturn readFunc(SyscallDesc *desc, int num,
-                       Process *p, ExecContext *xc);
+                       Process *p, ThreadContext *tc);
 
 /// Target write() handler.
 SyscallReturn writeFunc(SyscallDesc *desc, int num,
-                        Process *p, ExecContext *xc);
+                        Process *p, ThreadContext *tc);
 
 /// Target lseek() handler.
 SyscallReturn lseekFunc(SyscallDesc *desc, int num,
-                        Process *p, ExecContext *xc);
+                        Process *p, ThreadContext *tc);
 
 /// Target munmap() handler.
 SyscallReturn munmapFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 /// Target gethostname() handler.
 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
-                              Process *p, ExecContext *xc);
+                              Process *p, ThreadContext *tc);
 
 /// Target unlink() handler.
 SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 /// Target rename() handler.
 SyscallReturn renameFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 
 /// Target truncate() handler.
 SyscallReturn truncateFunc(SyscallDesc *desc, int num,
-                           Process *p, ExecContext *xc);
+                           Process *p, ThreadContext *tc);
 
 
 /// Target ftruncate() handler.
 SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
-                            Process *p, ExecContext *xc);
+                            Process *p, ThreadContext *tc);
 
 
 /// Target chown() handler.
 SyscallReturn chownFunc(SyscallDesc *desc, int num,
-                        Process *p, ExecContext *xc);
+                        Process *p, ThreadContext *tc);
 
 
 /// Target fchown() handler.
 SyscallReturn fchownFunc(SyscallDesc *desc, int num,
-                         Process *p, ExecContext *xc);
+                         Process *p, ThreadContext *tc);
 
 /// Target fnctl() handler.
 SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
-                        Process *process, ExecContext *xc);
+                        Process *process, ThreadContext *tc);
 
 /// Target setuid() handler.
 SyscallReturn setuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getpid() handler.
 SyscallReturn getpidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getuid() handler.
 SyscallReturn getuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getgid() handler.
 SyscallReturn getgidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getppid() handler.
 SyscallReturn getppidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target geteuid() handler.
 SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getegid() handler.
 SyscallReturn getegidFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 
 
 /// Pseudo Funcs  - These functions use a different return convension,
 /// returning a second value in a register other than the normal return register
 SyscallReturn pipePseudoFunc(SyscallDesc *desc, int num,
-                             Process *process, ExecContext *xc);
+                             Process *process, ThreadContext *tc);
 
 /// Target getpidPseudo() handler.
 SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getuidPseudo() handler.
 SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getgidPseudo() handler.
 SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
-                               Process *p, ExecContext *xc);
+                               Process *p, ThreadContext *tc);
 
 
 /// This struct is used to build an target-OS-dependent table that
@@ -338,10 +338,10 @@ getElapsedTime(T1 &sec, T2 &usec)
 template <class OS>
 SyscallReturn
 ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
-          ExecContext *xc)
+          ThreadContext *tc)
 {
-    int fd = xc->getSyscallArg(0);
-    unsigned req = xc->getSyscallArg(1);
+    int fd = tc->getSyscallArg(0);
+    unsigned req = tc->getSyscallArg(1);
 
     DPRINTF(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req);
 
@@ -363,7 +363,7 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
 
       default:
         fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ 0x%llx\n",
-              fd, req, xc->readPC());
+              fd, req, tc->readPC());
     }
 }
 
@@ -371,11 +371,11 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 openFunc(SyscallDesc *desc, int callnum, Process *process,
-         ExecContext *xc)
+         ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
         return -EFAULT;
 
     if (path == "/dev/sysdev0") {
@@ -385,8 +385,8 @@ openFunc(SyscallDesc *desc, int callnum, Process *process,
         return -ENOENT;
     }
 
-    int tgtFlags = xc->getSyscallArg(1);
-    int mode = xc->getSyscallArg(2);
+    int tgtFlags = tc->getSyscallArg(1);
+    int mode = tc->getSyscallArg(2);
     int hostFlags = 0;
 
     // translate open flags
@@ -418,14 +418,14 @@ openFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 chmodFunc(SyscallDesc *desc, int callnum, Process *process,
-          ExecContext *xc)
+          ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
         return -EFAULT;
 
-    uint32_t mode = xc->getSyscallArg(1);
+    uint32_t mode = tc->getSyscallArg(1);
     mode_t hostMode = 0;
 
     // XXX translate mode flags via OS::something???
@@ -444,15 +444,15 @@ chmodFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 fchmodFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
-    int fd = xc->getSyscallArg(0);
+    int fd = tc->getSyscallArg(0);
     if (fd < 0 || process->sim_fd(fd) < 0) {
         // doesn't map to any simulator fd: not a valid target fd
         return -EBADF;
     }
 
-    uint32_t mode = xc->getSyscallArg(1);
+    uint32_t mode = tc->getSyscallArg(1);
     mode_t hostMode = 0;
 
     // XXX translate mode flags via OS::someting???
@@ -471,11 +471,11 @@ fchmodFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 statFunc(SyscallDesc *desc, int callnum, Process *process,
-         ExecContext *xc)
+         ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
     return -EFAULT;
 
     struct stat hostBuf;
@@ -484,7 +484,7 @@ statFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStatBuf(xc->getMemPort(), xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -494,9 +494,9 @@ statFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 fstat64Func(SyscallDesc *desc, int callnum, Process *process,
-            ExecContext *xc)
+            ThreadContext *tc)
 {
-    int fd = xc->getSyscallArg(0);
+    int fd = tc->getSyscallArg(0);
     if (fd < 0 || process->sim_fd(fd) < 0) {
         // doesn't map to any simulator fd: not a valid target fd
         return -EBADF;
@@ -513,7 +513,7 @@ fstat64Func(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStat64Buf(xc->getMemPort(), fd, xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStat64Buf(tc->getMemPort(), fd, tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -523,11 +523,11 @@ fstat64Func(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 lstatFunc(SyscallDesc *desc, int callnum, Process *process,
-          ExecContext *xc)
+          ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
       return -EFAULT;
 
     struct stat hostBuf;
@@ -536,7 +536,7 @@ lstatFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStatBuf(xc->getMemPort(), xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -545,11 +545,11 @@ lstatFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 lstat64Func(SyscallDesc *desc, int callnum, Process *process,
-            ExecContext *xc)
+            ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
       return -EFAULT;
 
 #if BSD_HOST
@@ -563,7 +563,7 @@ lstat64Func(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStat64Buf(xc->getMemPort(), -1, xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStat64Buf(tc->getMemPort(), -1, tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -572,9 +572,9 @@ lstat64Func(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 fstatFunc(SyscallDesc *desc, int callnum, Process *process,
-          ExecContext *xc)
+          ThreadContext *tc)
 {
-    int fd = process->sim_fd(xc->getSyscallArg(0));
+    int fd = process->sim_fd(tc->getSyscallArg(0));
 
     DPRINTF(SyscallVerbose, "fstat(%d, ...)\n", fd);
 
@@ -587,7 +587,7 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStatBuf(xc->getMemPort(), xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -597,11 +597,11 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 statfsFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
       return -EFAULT;
 
     struct statfs hostBuf;
@@ -610,7 +610,7 @@ statfsFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStatfsBuf(xc->getMemPort(), xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -620,9 +620,9 @@ statfsFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
-            ExecContext *xc)
+            ThreadContext *tc)
 {
-    int fd = process->sim_fd(xc->getSyscallArg(0));
+    int fd = process->sim_fd(tc->getSyscallArg(0));
 
     if (fd < 0)
         return -EBADF;
@@ -633,7 +633,7 @@ fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
     if (result < 0)
         return -errno;
 
-    OS::copyOutStatfsBuf(xc->getMemPort(), xc->getSyscallArg(1), &hostBuf);
+    OS::copyOutStatfsBuf(tc->getMemPort(), tc->getSyscallArg(1), &hostBuf);
 
     return 0;
 }
@@ -643,17 +643,17 @@ fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 writevFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
-    int fd = xc->getSyscallArg(0);
+    int fd = tc->getSyscallArg(0);
     if (fd < 0 || process->sim_fd(fd) < 0) {
         // doesn't map to any simulator fd: not a valid target fd
         return -EBADF;
     }
 
-    TranslatingPort *p = xc->getMemPort();
-    uint64_t tiov_base = xc->getSyscallArg(1);
-    size_t count = xc->getSyscallArg(2);
+    TranslatingPort *p = tc->getMemPort();
+    uint64_t tiov_base = tc->getSyscallArg(1);
+    size_t count = tc->getSyscallArg(2);
     struct iovec hiov[count];
     for (int i = 0; i < count; ++i)
     {
@@ -695,14 +695,14 @@ writevFunc(SyscallDesc *desc, int callnum, Process *process,
 /// anything else.
 template <class OS>
 SyscallReturn
-mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
+mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
-    Addr start = xc->getSyscallArg(0);
-    uint64_t length = xc->getSyscallArg(1);
-    // int prot = xc->getSyscallArg(2);
-    int flags = xc->getSyscallArg(3);
-    // int fd = p->sim_fd(xc->getSyscallArg(4));
-    // int offset = xc->getSyscallArg(5);
+    Addr start = tc->getSyscallArg(0);
+    uint64_t length = tc->getSyscallArg(1);
+    // int prot = tc->getSyscallArg(2);
+    int flags = tc->getSyscallArg(3);
+    // int fd = p->sim_fd(tc->getSyscallArg(4));
+    // int offset = tc->getSyscallArg(5);
 
     if ((start  % TheISA::VMPageSize) != 0 ||
         (length % TheISA::VMPageSize) != 0) {
@@ -724,7 +724,7 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 
     if (!(flags & OS::TGT_MAP_ANONYMOUS)) {
         warn("allowing mmap of file @ fd %d. "
-             "This will break if not /dev/zero.", xc->getSyscallArg(4));
+             "This will break if not /dev/zero.", tc->getSyscallArg(4));
     }
 
     return start;
@@ -734,10 +734,10 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
 template <class OS>
 SyscallReturn
 getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
-        ExecContext *xc)
+        ThreadContext *tc)
 {
-    unsigned resource = xc->getSyscallArg(0);
-    TypedBufferArg<typename OS::rlimit> rlp(xc->getSyscallArg(1));
+    unsigned resource = tc->getSyscallArg(0);
+    TypedBufferArg<typename OS::rlimit> rlp(tc->getSyscallArg(1));
 
     switch (resource) {
         case OS::TGT_RLIMIT_STACK:
@@ -754,7 +754,7 @@ getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
             break;
     }
 
-    rlp.copyOut(xc->getMemPort());
+    rlp.copyOut(tc->getMemPort());
     return 0;
 }
 
@@ -762,16 +762,16 @@ getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
-        ExecContext *xc)
+        ThreadContext *tc)
 {
-    TypedBufferArg<typename OS::timeval> tp(xc->getSyscallArg(0));
+    TypedBufferArg<typename OS::timeval> tp(tc->getSyscallArg(0));
 
     getElapsedTime(tp->tv_sec, tp->tv_usec);
     tp->tv_sec += seconds_since_epoch;
     tp->tv_sec = htog(tp->tv_sec);
     tp->tv_usec = htog(tp->tv_usec);
 
-    tp.copyOut(xc->getMemPort());
+    tp.copyOut(tc->getMemPort());
 
     return 0;
 }
@@ -781,15 +781,15 @@ gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 utimesFunc(SyscallDesc *desc, int callnum, Process *process,
-           ExecContext *xc)
+           ThreadContext *tc)
 {
     std::string path;
 
-    if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
+    if (!tc->getMemPort()->tryReadString(path, tc->getSyscallArg(0)))
       return -EFAULT;
 
-    TypedBufferArg<typename OS::timeval [2]> tp(xc->getSyscallArg(1));
-    tp.copyIn(xc->getMemPort());
+    TypedBufferArg<typename OS::timeval [2]> tp(tc->getSyscallArg(1));
+    tp.copyIn(tc->getMemPort());
 
     struct timeval hostTimeval[2];
     for (int i = 0; i < 2; ++i)
@@ -808,10 +808,10 @@ utimesFunc(SyscallDesc *desc, int callnum, Process *process,
 template <class OS>
 SyscallReturn
 getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
-              ExecContext *xc)
+              ThreadContext *tc)
 {
-    int who = xc->getSyscallArg(0);	// THREAD, SELF, or CHILDREN
-    TypedBufferArg<typename OS::rusage> rup(xc->getSyscallArg(1));
+    int who = tc->getSyscallArg(0);	// THREAD, SELF, or CHILDREN
+    TypedBufferArg<typename OS::rusage> rup(tc->getSyscallArg(1));
 
     if (who != OS::TGT_RUSAGE_SELF) {
         // don't really handle THREAD or CHILDREN, but just warn and
@@ -841,7 +841,7 @@ getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
     rup->ru_nvcsw = 0;
     rup->ru_nivcsw = 0;
 
-    rup.copyOut(xc->getMemPort());
+    rup.copyOut(tc->getMemPort());
 
     return 0;
 }
diff --git a/src/sim/system.cc b/src/sim/system.cc
index 89f39491e..e177aa84c 100644
--- a/src/sim/system.cc
+++ b/src/sim/system.cc
@@ -2,7 +2,7 @@
 #include "base/loader/object_file.hh"
 #include "base/loader/symtab.hh"
 #include "base/trace.hh"
-#include "cpu/exec_context.hh"
+#include "cpu/thread_context.hh"
 #include "mem/mem_object.hh"
 #include "mem/physical.hh"
 #include "sim/builder.hh"
@@ -115,26 +115,26 @@ int rgdb_wait = -1;
 #endif // FULL_SYSTEM
 
 int
-System::registerExecContext(ExecContext *xc, int id)
+System::registerThreadContext(ThreadContext *tc, int id)
 {
     if (id == -1) {
-        for (id = 0; id < execContexts.size(); id++) {
-            if (!execContexts[id])
+        for (id = 0; id < threadContexts.size(); id++) {
+            if (!threadContexts[id])
                 break;
         }
     }
 
-    if (execContexts.size() <= id)
-        execContexts.resize(id + 1);
+    if (threadContexts.size() <= id)
+        threadContexts.resize(id + 1);
 
-    if (execContexts[id])
+    if (threadContexts[id])
         panic("Cannot have two CPUs with the same id (%d)\n", id);
 
-    execContexts[id] = xc;
+    threadContexts[id] = tc;
     numcpus++;
 
 #if FULL_SYSTEM
-    RemoteGDB *rgdb = new RemoteGDB(this, xc);
+    RemoteGDB *rgdb = new RemoteGDB(this, tc);
     GDBListener *gdbl = new GDBListener(rgdb, 7000 + id);
     gdbl->listen();
     /**
@@ -158,21 +158,21 @@ void
 System::startup()
 {
     int i;
-    for (i = 0; i < execContexts.size(); i++)
-        execContexts[i]->activate(0);
+    for (i = 0; i < threadContexts.size(); i++)
+        threadContexts[i]->activate(0);
 }
 
 void
-System::replaceExecContext(ExecContext *xc, int id)
+System::replaceThreadContext(ThreadContext *tc, int id)
 {
-    if (id >= execContexts.size()) {
-        panic("replaceExecContext: bad id, %d >= %d\n",
-              id, execContexts.size());
+    if (id >= threadContexts.size()) {
+        panic("replaceThreadContext: bad id, %d >= %d\n",
+              id, threadContexts.size());
     }
 
-    execContexts[id] = xc;
+    threadContexts[id] = tc;
 #if FULL_SYSTEM
-    remoteGDB[id]->replaceExecContext(xc);
+    remoteGDB[id]->replaceThreadContext(tc);
 #endif // FULL_SYSTEM
 }
 
diff --git a/src/sim/system.hh b/src/sim/system.hh
index 65cb0c95c..3a9fdc3d2 100644
--- a/src/sim/system.hh
+++ b/src/sim/system.hh
@@ -48,7 +48,7 @@
 #endif
 
 class BaseCPU;
-class ExecContext;
+class ThreadContext;
 class ObjectFile;
 class PhysicalMemory;
 
@@ -65,12 +65,12 @@ class System : public SimObject
     PhysicalMemory *physmem;
     PCEventQueue pcEventQueue;
 
-    std::vector<ExecContext *> execContexts;
+    std::vector<ThreadContext *> threadContexts;
     int numcpus;
 
     int getNumCPUs()
     {
-        if (numcpus != execContexts.size())
+        if (numcpus != threadContexts.size())
             panic("cpu array not fully populated!");
 
         return numcpus;
@@ -208,8 +208,8 @@ class System : public SimObject
 
 #endif // FULL_SYSTEM
 
-    int registerExecContext(ExecContext *xc, int xcIndex);
-    void replaceExecContext(ExecContext *xc, int xcIndex);
+    int registerThreadContext(ThreadContext *tc, int tcIndex);
+    void replaceThreadContext(ThreadContext *tc, int tcIndex);
 
     void regStats();
     void serialize(std::ostream &os);
diff --git a/src/sim/vptr.hh b/src/sim/vptr.hh
index a0e74139f..bcc22f0ca 100644
--- a/src/sim/vptr.hh
+++ b/src/sim/vptr.hh
@@ -34,7 +34,7 @@
 #include "arch/vtophys.hh"
 #include "arch/isa_traits.hh"
 
-class ExecContext;
+class ThreadContext;
 
 template <class T>
 class VPtr
@@ -43,17 +43,17 @@ class VPtr
     typedef T Type;
 
   private:
-    ExecContext *xc;
+    ThreadContext *tc;
     Addr ptr;
 
   public:
-    ExecContext *GetXC() const { return xc; }
+    ThreadContext *GetTC() const { return tc; }
     Addr GetPointer() const { return ptr; }
 
   public:
-    explicit VPtr(ExecContext *_xc, Addr p = 0) : xc(_xc), ptr(p) { }
+    explicit VPtr(ThreadContext *_tc, Addr p = 0) : tc(_tc), ptr(p) { }
     template <class U>
-    VPtr(const VPtr<U> &vp) : xc(vp.GetXC()), ptr(vp.GetPointer()) {}
+    VPtr(const VPtr<U> &vp) : tc(vp.GetTC()), ptr(vp.GetPointer()) {}
     ~VPtr() {}
 
     bool operator!() const
@@ -90,7 +90,7 @@ class VPtr
     template <class U>
     const VPtr<T> &operator=(const VPtr<U> &vp)
     {
-        xc = vp.GetXC();
+        tc = vp.GetTC();
         ptr = vp.GetPointer();
 
         return *this;
@@ -99,7 +99,7 @@ class VPtr
     operator T *()
     {
         panic("Needs to be rewritten\n");
-/*	void *addr = vtomem(xc, ptr, sizeof(T));
+/*	void *addr = vtomem(tc, ptr, sizeof(T));
         return (T *)addr;
         */
     }
@@ -107,7 +107,7 @@ class VPtr
     T *operator->()
     {
         panic("Needs to be rewritten\n");
-/*	void *addr = vtomem(xc, ptr, sizeof(T));
+/*	void *addr = vtomem(tc, ptr, sizeof(T));
         return (T *)addr;
         */
     }
@@ -115,7 +115,7 @@ class VPtr
     T &operator*()
     {
         panic("Needs to be rewritten\n");
-/*	void *addr = vtomem(xc, ptr, sizeof(T));
+/*	void *addr = vtomem(tc, ptr, sizeof(T));
         return *(T *)addr;
         */
     }