Merge m5.eecs.umich.edu:/bk/newmem

into  ewok.(none):/home/gblack/m5/newmem

src/arch/sparc/regfile.hh:
    Hand Merge

--HG--
extra : convert_revision : c47202689202069892524a7d71962082469996ee

10 files changed, 160 insertions, 137 deletions

diff --git a/src/kern/tru64/dump_mbuf.cc b/src/kern/tru64/dump_mbuf.cc
index c3c37531a..8f88f8904 100644
--- a/src/kern/tru64/dump_mbuf.cc
+++ b/src/kern/tru64/dump_mbuf.cc
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #include <sys/types.h>
@@ -32,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"
@@ -47,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;
 
@@ -62,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;
 
@@ -71,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/dump_mbuf.hh b/src/kern/tru64/dump_mbuf.hh
index 9e1698ff1..25c6fd31d 100644
--- a/src/kern/tru64/dump_mbuf.hh
+++ b/src/kern/tru64/dump_mbuf.hh
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #ifndef __DUMP_MBUF_HH__
diff --git a/src/kern/tru64/mbuf.hh b/src/kern/tru64/mbuf.hh
index 93424858f..cb5a84a7e 100644
--- a/src/kern/tru64/mbuf.hh
+++ b/src/kern/tru64/mbuf.hh
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #ifndef __MBUF_HH__
diff --git a/src/kern/tru64/printf.cc b/src/kern/tru64/printf.cc
index 319d36673..29dd443d2 100644
--- a/src/kern/tru64/printf.cc
+++ b/src/kern/tru64/printf.cc
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #include <sys/types.h>
diff --git a/src/kern/tru64/printf.hh b/src/kern/tru64/printf.hh
index 61236e83a..f6a4544ad 100644
--- a/src/kern/tru64/printf.hh
+++ b/src/kern/tru64/printf.hh
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #ifndef __PRINTF_HH__
diff --git a/src/kern/tru64/tru64.hh b/src/kern/tru64/tru64.hh
index 91db5bb84..d2b7c862f 100644
--- a/src/kern/tru64/tru64.hh
+++ b/src/kern/tru64/tru64.hh
@@ -24,6 +24,9 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
+ *          Ali Saidi
  */
 
 #ifndef __TRU64_HH__
@@ -576,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);
 
@@ -619,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;
@@ -628,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
@@ -637,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;
     }
@@ -670,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.
@@ -685,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;
@@ -700,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! "
@@ -749,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,
@@ -762,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
@@ -786,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);
             }
@@ -796,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;
@@ -811,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! "
@@ -869,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);
 
@@ -880,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) {
@@ -894,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 =
@@ -904,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 "
@@ -916,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::Unallocated) {
+                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;
                 }
@@ -951,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;
     }
@@ -959,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;
@@ -978,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
@@ -1001,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;
@@ -1016,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
@@ -1029,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,
@@ -1045,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
@@ -1063,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.
@@ -1097,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
@@ -1119,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;
@@ -1141,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;
     }
@@ -1153,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);
@@ -1166,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);
 
@@ -1178,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;
     }
@@ -1202,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;
     }
@@ -1213,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 69fc5c55d..69638bde1 100644
--- a/src/kern/tru64/tru64_events.cc
+++ b/src/kern/tru64/tru64_events.cc
@@ -24,9 +24,12 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
+ *          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"
@@ -39,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))
@@ -65,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 9b5bcfea2..6a1ab2e51 100644
--- a/src/kern/tru64/tru64_events.hh
+++ b/src/kern/tru64/tru64_events.hh
@@ -24,6 +24,9 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
+ *          Lisa Hsu
  */
 
 #ifndef __TRU64_EVENTS_HH__
@@ -34,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
@@ -49,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
@@ -61,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
@@ -77,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__
diff --git a/src/kern/tru64/tru64_syscalls.cc b/src/kern/tru64/tru64_syscalls.cc
index 8aa57dbaa..8051b9efb 100644
--- a/src/kern/tru64/tru64_syscalls.cc
+++ b/src/kern/tru64/tru64_syscalls.cc
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #include "kern/tru64/tru64_syscalls.hh"
diff --git a/src/kern/tru64/tru64_syscalls.hh b/src/kern/tru64/tru64_syscalls.hh
index 69fa9101c..66f5c2d39 100644
--- a/src/kern/tru64/tru64_syscalls.hh
+++ b/src/kern/tru64/tru64_syscalls.hh
@@ -24,6 +24,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
  */
 
 #ifndef __KERN_TRU64_TRU64_SYSCALLS_HH__