# Node ID c915cc7cff42d4b0f25a4077e483287ecf5519b3
# Parent  3df85192a1b2919950641f8bda0eabae7ae4d912
diff --git a/configs/common/cpu2000.py b/configs/common/cpu2000.py
--- a/configs/common/cpu2000.py
+++ b/configs/common/cpu2000.py
@@ -131,8 +131,8 @@
 
         func(self, isa, os)
 
-    def makeLiveProcessArgs(self, **kwargs):
-        # set up default args for LiveProcess object
+    def makeProcessArgs(self, **kwargs):
+        # set up default args for Process object
         process_args = {}
         process_args['cmd'] = [ self.name ] + self.args
         process_args['executable'] = self.executable
@@ -147,11 +147,11 @@
 
         return process_args
 
-    def makeLiveProcess(self, **kwargs):
-        process_args = self.makeLiveProcessArgs(**kwargs)
+    def makeProcess(self, **kwargs):
+        process_args = self.makeProcessArgs(**kwargs)
 
         # figure out working directory: use m5's outdir unless
-        # overridden by LiveProcess's cwd param
+        # overridden by Process's cwd param
         cwd = process_args.get('cwd')
 
         if not cwd:
@@ -163,9 +163,9 @@
         # copy input files to working directory
         for d in self.inputs_dir:
             copyfiles(d, cwd)
-        # generate LiveProcess object
-        from m5.objects import LiveProcess
-        return LiveProcess(**process_args)
+        # generate Process object
+        from m5.objects import Process
+        return Process(**process_args)
 
     def __str__(self):
         return self.name
@@ -750,5 +750,5 @@
             print 'class: %s' % bench.__name__
             x = bench('alpha', 'tru64', input_set)
             print '%s: %s' % (x, input_set)
-            pprint(x.makeLiveProcessArgs())
+            pprint(x.makeProcessArgs())
             print
diff --git a/configs/example/apu_se.py b/configs/example/apu_se.py
--- a/configs/example/apu_se.py
+++ b/configs/example/apu_se.py
@@ -388,9 +388,9 @@
 # OpenCL driver
 driver = ClDriver(filename="hsa", codefile=kernel_files)
 for cpu in cpu_list:
-    cpu.workload = LiveProcess(executable = executable,
-                               cmd = [options.cmd] + options.options.split(),
-                               drivers = [driver])
+    cpu.workload = Process(executable = executable,
+                           cmd = [options.cmd] + options.options.split(),
+                           drivers = [driver])
 for cp in cp_list:
     cp.workload = host_cpu.workload
 
diff --git a/configs/example/se.py b/configs/example/se.py
--- a/configs/example/se.py
+++ b/configs/example/se.py
@@ -91,7 +91,7 @@
 
     idx = 0
     for wrkld in workloads:
-        process = LiveProcess()
+        process = Process()
         process.executable = wrkld
         process.cwd = os.getcwd()
 
@@ -154,7 +154,7 @@
             else:
                 exec("workload = %s(buildEnv['TARGET_ISA', 'linux', '%s')" % (
                         app, options.spec_input))
-            multiprocesses.append(workload.makeLiveProcess())
+            multiprocesses.append(workload.makeProcess())
         except:
             print >>sys.stderr, "Unable to find workload for %s: %s" % (
                     buildEnv['TARGET_ISA'], app)
diff --git a/configs/learning_gem5/part1/simple.py b/configs/learning_gem5/part1/simple.py
--- a/configs/learning_gem5/part1/simple.py
+++ b/configs/learning_gem5/part1/simple.py
@@ -89,7 +89,7 @@
 binary = 'tests/test-progs/hello/bin/' + isa + '/linux/hello'
 
 # Create a process for a simple "Hello World" application
-process = LiveProcess()
+process = Process()
 # Set the command
 # cmd is a list which begins with the executable (like argv)
 process.cmd = [binary]
diff --git a/configs/learning_gem5/part1/two_level.py b/configs/learning_gem5/part1/two_level.py
--- a/configs/learning_gem5/part1/two_level.py
+++ b/configs/learning_gem5/part1/two_level.py
@@ -133,7 +133,7 @@
 system.mem_ctrl.port = system.membus.master
 
 # Create a process for a simple "Hello World" application
-process = LiveProcess()
+process = Process()
 # Set the command
 # cmd is a list which begins with the executable (like argv)
 process.cmd = [binary]
diff --git a/configs/splash2/cluster.py b/configs/splash2/cluster.py
--- a/configs/splash2/cluster.py
+++ b/configs/splash2/cluster.py
@@ -76,56 +76,56 @@
 # --------------------
 # Define Splash2 Benchmarks
 # ====================
-class Cholesky(LiveProcess):
+class Cholesky(Process):
         executable = options.rootdir + '/kernels/cholesky/CHOLESKY'
         cmd = 'CHOLESKY -p' + str(options.numcpus) + ' '\
              + options.rootdir + '/kernels/cholesky/inputs/tk23.O'
 
-class FFT(LiveProcess):
+class FFT(Process):
         executable = options.rootdir + 'kernels/fft/FFT'
         cmd = 'FFT -p' + str(options.numcpus) + ' -m18'
 
-class LU_contig(LiveProcess):
+class LU_contig(Process):
         executable = options.rootdir + 'kernels/lu/contiguous_blocks/LU'
         cmd = 'LU -p' + str(options.numcpus)
 
-class LU_noncontig(LiveProcess):
+class LU_noncontig(Process):
         executable = options.rootdir + 'kernels/lu/non_contiguous_blocks/LU'
         cmd = 'LU -p' + str(options.numcpus)
 
-class Radix(LiveProcess):
+class Radix(Process):
         executable = options.rootdir + 'kernels/radix/RADIX'
         cmd = 'RADIX -n524288 -p' + str(options.numcpus)
 
-class Barnes(LiveProcess):
+class Barnes(Process):
         executable = options.rootdir + 'apps/barnes/BARNES'
         cmd = 'BARNES'
         input = options.rootdir + 'apps/barnes/input.p' + str(options.numcpus)
 
-class FMM(LiveProcess):
+class FMM(Process):
         executable = options.rootdir + 'apps/fmm/FMM'
         cmd = 'FMM'
         input = options.rootdir + 'apps/fmm/inputs/input.2048.p' + str(options.numcpus)
 
-class Ocean_contig(LiveProcess):
+class Ocean_contig(Process):
         executable = options.rootdir + 'apps/ocean/contiguous_partitions/OCEAN'
         cmd = 'OCEAN -p' + str(options.numcpus)
 
-class Ocean_noncontig(LiveProcess):
+class Ocean_noncontig(Process):
         executable = options.rootdir + 'apps/ocean/non_contiguous_partitions/OCEAN'
         cmd = 'OCEAN -p' + str(options.numcpus)
 
-class Raytrace(LiveProcess):
+class Raytrace(Process):
         executable = options.rootdir + 'apps/raytrace/RAYTRACE'
         cmd = 'RAYTRACE -p' + str(options.numcpus) + ' ' \
              + options.rootdir + 'apps/raytrace/inputs/teapot.env'
 
-class Water_nsquared(LiveProcess):
+class Water_nsquared(Process):
         executable = options.rootdir + 'apps/water-nsquared/WATER-NSQUARED'
         cmd = 'WATER-NSQUARED'
         input = options.rootdir + 'apps/water-nsquared/input.p' + str(options.numcpus)
 
-class Water_spatial(LiveProcess):
+class Water_spatial(Process):
         executable = options.rootdir + 'apps/water-spatial/WATER-SPATIAL'
         cmd = 'WATER-SPATIAL'
         input = options.rootdir + 'apps/water-spatial/input.p' + str(options.numcpus)
diff --git a/configs/splash2/run.py b/configs/splash2/run.py
--- a/configs/splash2/run.py
+++ b/configs/splash2/run.py
@@ -77,39 +77,39 @@
 # --------------------
 # Define Splash2 Benchmarks
 # ====================
-class Cholesky(LiveProcess):
+class Cholesky(Process):
     cwd = options.rootdir + '/kernels/cholesky'
     executable = options.rootdir + '/kernels/cholesky/CHOLESKY'
     cmd = ['CHOLESKY', '-p' +  str(options.numcpus),
             options.rootdir + '/kernels/cholesky/inputs/tk23.O']
 
-class FFT(LiveProcess):
+class FFT(Process):
     cwd = options.rootdir + '/kernels/fft'
     executable = options.rootdir + '/kernels/fft/FFT'
     cmd = ['FFT', '-p', str(options.numcpus), '-m18']
 
-class LU_contig(LiveProcess):
+class LU_contig(Process):
     executable = options.rootdir + '/kernels/lu/contiguous_blocks/LU'
     cmd = ['LU', '-p', str(options.numcpus)]
     cwd = options.rootdir + '/kernels/lu/contiguous_blocks'
 
-class LU_noncontig(LiveProcess):
+class LU_noncontig(Process):
     executable = options.rootdir + '/kernels/lu/non_contiguous_blocks/LU'
     cmd = ['LU', '-p', str(options.numcpus)]
     cwd = options.rootdir + '/kernels/lu/non_contiguous_blocks'
 
-class Radix(LiveProcess):
+class Radix(Process):
     executable = options.rootdir + '/kernels/radix/RADIX'
     cmd = ['RADIX', '-n524288', '-p', str(options.numcpus)]
     cwd = options.rootdir + '/kernels/radix'
 
-class Barnes(LiveProcess):
+class Barnes(Process):
     executable = options.rootdir + '/apps/barnes/BARNES'
     cmd = ['BARNES']
     input = options.rootdir + '/apps/barnes/input.p' + str(options.numcpus)
     cwd = options.rootdir + '/apps/barnes'
 
-class FMM(LiveProcess):
+class FMM(Process):
     executable = options.rootdir + '/apps/fmm/FMM'
     cmd = ['FMM']
     if str(options.numcpus) == '1':
@@ -118,23 +118,23 @@
         input = options.rootdir + '/apps/fmm/inputs/input.2048.p' + str(options.numcpus)
     cwd = options.rootdir + '/apps/fmm'
 
-class Ocean_contig(LiveProcess):
+class Ocean_contig(Process):
     executable = options.rootdir + '/apps/ocean/contiguous_partitions/OCEAN'
     cmd = ['OCEAN', '-p', str(options.numcpus)]
     cwd = options.rootdir + '/apps/ocean/contiguous_partitions'
 
-class Ocean_noncontig(LiveProcess):
+class Ocean_noncontig(Process):
     executable = options.rootdir + '/apps/ocean/non_contiguous_partitions/OCEAN'
     cmd = ['OCEAN', '-p', str(options.numcpus)]
     cwd = options.rootdir + '/apps/ocean/non_contiguous_partitions'
 
-class Raytrace(LiveProcess):
+class Raytrace(Process):
     executable = options.rootdir + '/apps/raytrace/RAYTRACE'
     cmd = ['RAYTRACE', '-p' + str(options.numcpus),
            options.rootdir + '/apps/raytrace/inputs/teapot.env']
     cwd = options.rootdir + '/apps/raytrace'
 
-class Water_nsquared(LiveProcess):
+class Water_nsquared(Process):
     executable = options.rootdir + '/apps/water-nsquared/WATER-NSQUARED'
     cmd = ['WATER-NSQUARED']
     if options.numcpus==1:
@@ -143,7 +143,7 @@
         input = options.rootdir + '/apps/water-nsquared/input.p' + str(options.numcpus)
     cwd = options.rootdir + '/apps/water-nsquared'
 
-class Water_spatial(LiveProcess):
+class Water_spatial(Process):
     executable = options.rootdir + '/apps/water-spatial/WATER-SPATIAL'
     cmd = ['WATER-SPATIAL']
     if options.numcpus==1:
diff --git a/src/arch/alpha/linux/process.hh b/src/arch/alpha/linux/process.hh
--- a/src/arch/alpha/linux/process.hh
+++ b/src/arch/alpha/linux/process.hh
@@ -36,11 +36,11 @@
 namespace AlphaISA  {
 
 /// A process with emulated Alpha/Linux syscalls.
-class AlphaLinuxProcess : public AlphaLiveProcess
+class AlphaLinuxProcess : public AlphaProcess
 {
   public:
     /// Constructor.
-    AlphaLinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    AlphaLinuxProcess(ProcessParams * params, ObjectFile *objFile);
 
     virtual SyscallDesc* getDesc(int callnum);
 
diff --git a/src/arch/alpha/linux/process.cc b/src/arch/alpha/linux/process.cc
--- a/src/arch/alpha/linux/process.cc
+++ b/src/arch/alpha/linux/process.cc
@@ -46,7 +46,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -66,7 +66,7 @@
 /// borrowed from Tru64, the subcases that get used appear to be
 /// different in practice from those used by Tru64 processes.
 static SyscallReturn
-osf_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+osf_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                    ThreadContext *tc)
 {
     int index = 0;
@@ -95,7 +95,7 @@
 
 /// Target osf_setsysinfo() handler.
 static SyscallReturn
-osf_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+osf_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                    ThreadContext *tc)
 {
     int index = 0;
@@ -572,9 +572,9 @@
     /* 441 */ SyscallDesc("keyctl", unimplementedFunc)
 };
 
-AlphaLinuxProcess::AlphaLinuxProcess(LiveProcessParams * params,
+AlphaLinuxProcess::AlphaLinuxProcess(ProcessParams * params,
                                      ObjectFile *objFile)
-    : AlphaLiveProcess(params, objFile),
+    : AlphaProcess(params, objFile),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
     //init_regs->intRegFile[0] = 0;
diff --git a/src/arch/alpha/process.hh b/src/arch/alpha/process.hh
--- a/src/arch/alpha/process.hh
+++ b/src/arch/alpha/process.hh
@@ -35,13 +35,13 @@
 #include "mem/page_table.hh"
 #include "sim/process.hh"
 
-class AlphaLiveProcess : public LiveProcess
+class AlphaProcess : public Process
 {
   private:
     void setupASNReg();
 
   protected:
-    AlphaLiveProcess(LiveProcessParams *params, ObjectFile *objFile);
+    AlphaProcess(ProcessParams *params, ObjectFile *objFile);
 
     void loadState(CheckpointIn &cp) override;
     void initState() override;
@@ -51,12 +51,12 @@
   public:
     AlphaISA::IntReg getSyscallArg(ThreadContext *tc, int &i) override;
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
     void setSyscallArg(ThreadContext *tc, int i, AlphaISA::IntReg val) override;
     void setSyscallReturn(ThreadContext *tc,
                           SyscallReturn return_value) override;
 
-    // override default implementation in LiveProcess as the mmap
+    // override default implementation in Process as the mmap
     // region for Alpha platforms grows upward
     virtual bool mmapGrowsDown() const override { return false; }
 };
diff --git a/src/arch/alpha/process.cc b/src/arch/alpha/process.cc
--- a/src/arch/alpha/process.cc
+++ b/src/arch/alpha/process.cc
@@ -46,9 +46,8 @@
 using namespace AlphaISA;
 using namespace std;
 
-AlphaLiveProcess::AlphaLiveProcess(LiveProcessParams *params,
-                                   ObjectFile *objFile)
-    : LiveProcess(params, objFile)
+AlphaProcess::AlphaProcess(ProcessParams *params, ObjectFile *objFile)
+    : Process(params, objFile)
 {
     brk_point = objFile->dataBase() + objFile->dataSize() + objFile->bssSize();
     brk_point = roundUp(brk_point, PageBytes);
@@ -67,7 +66,7 @@
 }
 
 void
-AlphaLiveProcess::argsInit(int intSize, int pageSize)
+AlphaProcess::argsInit(int intSize, int pageSize)
 {
     // Patch the ld_bias for dynamic executables.
     updateBias();
@@ -176,7 +175,7 @@
 }
 
 void
-AlphaLiveProcess::setupASNReg()
+AlphaProcess::setupASNReg()
 {
     ThreadContext *tc = system->getThreadContext(contextIds[0]);
     tc->setMiscRegNoEffect(IPR_DTB_ASN, _pid << 57);
@@ -184,9 +183,9 @@
 
 
 void
-AlphaLiveProcess::loadState(CheckpointIn &cp)
+AlphaProcess::loadState(CheckpointIn &cp)
 {
-    LiveProcess::loadState(cp);
+    Process::loadState(cp);
     // need to set up ASN after unserialization since _pid value may
     // come from checkpoint
     setupASNReg();
@@ -194,13 +193,13 @@
 
 
 void
-AlphaLiveProcess::initState()
+AlphaProcess::initState()
 {
     // need to set up ASN before further initialization since init
     // will involve writing to virtual memory addresses
     setupASNReg();
 
-    LiveProcess::initState();
+    Process::initState();
 
     argsInit(MachineBytes, PageBytes);
 
@@ -214,22 +213,21 @@
 }
 
 AlphaISA::IntReg
-AlphaLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+AlphaProcess::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 6);
     return tc->readIntReg(FirstArgumentReg + i++);
 }
 
 void
-AlphaLiveProcess::setSyscallArg(ThreadContext *tc,
-        int i, AlphaISA::IntReg val)
+AlphaProcess::setSyscallArg(ThreadContext *tc, int i, AlphaISA::IntReg val)
 {
     assert(i < 6);
     tc->setIntReg(FirstArgumentReg + i, val);
 }
 
 void
-AlphaLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+AlphaProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
     // check for error condition.  Alpha syscall convention is to
     // indicate success/failure in reg a3 (r19) and put the
diff --git a/src/arch/alpha/tru64/process.hh b/src/arch/alpha/tru64/process.hh
--- a/src/arch/alpha/tru64/process.hh
+++ b/src/arch/alpha/tru64/process.hh
@@ -36,12 +36,11 @@
 namespace AlphaISA {
 
 /// A process with emulated Alpha Tru64 syscalls.
-class AlphaTru64Process : public AlphaLiveProcess
+class AlphaTru64Process : public AlphaProcess
 {
   public:
     /// Constructor.
-    AlphaTru64Process(LiveProcessParams * params,
-                      ObjectFile *objFile);
+    AlphaTru64Process(ProcessParams * params, ObjectFile *objFile);
 
     /// Array of syscall descriptors, indexed by call number.
     static SyscallDesc syscallDescs[];
diff --git a/src/arch/alpha/tru64/process.cc b/src/arch/alpha/tru64/process.cc
--- a/src/arch/alpha/tru64/process.cc
+++ b/src/arch/alpha/tru64/process.cc
@@ -45,8 +45,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-          ThreadContext *tc)
+unameFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
 {
     int index = 0;
     TypedBufferArg<AlphaTru64::utsname> name(process->getSyscallArg(tc, index));
@@ -63,7 +62,7 @@
 
 /// Target getsysyinfo() handler.
 static SyscallReturn
-getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                ThreadContext *tc)
 {
     int index = 0;
@@ -144,7 +143,7 @@
 
 /// Target setsysyinfo() handler.
 static SyscallReturn
-setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                ThreadContext *tc)
 {
     int index = 0;
@@ -166,8 +165,7 @@
 
 /// Target table() handler.
 static SyscallReturn
-tableFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-          ThreadContext *tc)
+tableFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
 {
     using namespace std;
 
@@ -577,9 +575,9 @@
         return &syscallDescs[callnum];
 }
 
-AlphaTru64Process::AlphaTru64Process(LiveProcessParams *params,
-    ObjectFile *objFile)
-    : AlphaLiveProcess(params, objFile),
+AlphaTru64Process::AlphaTru64Process(ProcessParams *params,
+                                     ObjectFile *objFile)
+    : AlphaProcess(params, objFile),
       Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc)),
       Num_Mach_Syscall_Descs(sizeof(machSyscallDescs) / sizeof(SyscallDesc))
 {
diff --git a/src/arch/arm/freebsd/process.hh b/src/arch/arm/freebsd/process.hh
--- a/src/arch/arm/freebsd/process.hh
+++ b/src/arch/arm/freebsd/process.hh
@@ -55,16 +55,16 @@
 };
 
 /// A process with emulated Arm/Freebsd syscalls.
-class ArmFreebsdProcess32 : public ArmLiveProcess32, public ArmFreebsdProcessBits
+class ArmFreebsdProcess32 : public ArmProcess32, public ArmFreebsdProcessBits
 {
   public:
-    ArmFreebsdProcess32(LiveProcessParams * params, ObjectFile *objFile,
-                      ObjectFile::Arch _arch);
+    ArmFreebsdProcess32(ProcessParams * params, ObjectFile *objFile,
+                        ObjectFile::Arch _arch);
 
     void initState();
 
     /// Explicitly import the otherwise hidden getSyscallArg
-    using ArmLiveProcess::getSyscallArg;
+    using ArmProcess::getSyscallArg;
 
     /// A page to hold "kernel" provided functions. The name might be wrong.
     static const Addr commPage;
@@ -73,11 +73,11 @@
 };
 
 /// A process with emulated Arm/Freebsd syscalls.
-class ArmFreebsdProcess64 : public ArmLiveProcess64, public ArmFreebsdProcessBits
+class ArmFreebsdProcess64 : public ArmProcess64, public ArmFreebsdProcessBits
 {
   public:
-    ArmFreebsdProcess64(LiveProcessParams * params, ObjectFile *objFile,
-                      ObjectFile::Arch _arch);
+    ArmFreebsdProcess64(ProcessParams * params, ObjectFile *objFile,
+                        ObjectFile::Arch _arch);
 
     void initState();
     SyscallDesc* getDesc(int callnum);
diff --git a/src/arch/arm/freebsd/process.cc b/src/arch/arm/freebsd/process.cc
--- a/src/arch/arm/freebsd/process.cc
+++ b/src/arch/arm/freebsd/process.cc
@@ -53,7 +53,7 @@
 using namespace ArmISA;
 
 static SyscallReturn
-issetugidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+issetugidFunc(SyscallDesc *desc, int callnum, Process *process,
               ThreadContext *tc)
 {
 
@@ -61,7 +61,7 @@
 }
 
 static SyscallReturn
-sysctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+sysctlFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     int index = 0;
@@ -1206,9 +1206,9 @@
     /*  547 */ SyscallDesc("unused#547", unimplementedFunc),
 };
 
-ArmFreebsdProcess32::ArmFreebsdProcess32(LiveProcessParams * params,
+ArmFreebsdProcess32::ArmFreebsdProcess32(ProcessParams * params,
         ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess32(params, objFile, _arch)
+    : ArmProcess32(params, objFile, _arch)
 {
     SyscallTable table;
 
@@ -1218,9 +1218,9 @@
     syscallTables.push_back(table);
 }
 
-ArmFreebsdProcess64::ArmFreebsdProcess64(LiveProcessParams * params,
+ArmFreebsdProcess64::ArmFreebsdProcess64(ProcessParams * params,
         ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess64(params, objFile, _arch)
+    : ArmProcess64(params, objFile, _arch)
 {
     SyscallTable table;
 
@@ -1269,13 +1269,13 @@
 void
 ArmFreebsdProcess32::initState()
 {
-    ArmLiveProcess32::initState();
+    ArmProcess32::initState();
     // The 32 bit equivalent of the comm page would be set up here.
 }
 
 void
 ArmFreebsdProcess64::initState()
 {
-    ArmLiveProcess64::initState();
+    ArmProcess64::initState();
     // The 64 bit equivalent of the comm page would be set up here.
 }
diff --git a/src/arch/arm/linux/process.hh b/src/arch/arm/linux/process.hh
--- a/src/arch/arm/linux/process.hh
+++ b/src/arch/arm/linux/process.hh
@@ -65,16 +65,16 @@
 };
 
 /// A process with emulated Arm/Linux syscalls.
-class ArmLinuxProcess32 : public ArmLiveProcess32, public ArmLinuxProcessBits
+class ArmLinuxProcess32 : public ArmProcess32, public ArmLinuxProcessBits
 {
   public:
-    ArmLinuxProcess32(LiveProcessParams * params, ObjectFile *objFile,
+    ArmLinuxProcess32(ProcessParams * params, ObjectFile *objFile,
                       ObjectFile::Arch _arch);
 
     void initState();
 
     /// Explicitly import the otherwise hidden getSyscallArg
-    using ArmLiveProcess::getSyscallArg;
+    using ArmProcess::getSyscallArg;
 
     /// A page to hold "kernel" provided functions. The name might be wrong.
     static const Addr commPage;
@@ -83,10 +83,10 @@
 };
 
 /// A process with emulated Arm/Linux syscalls.
-class ArmLinuxProcess64 : public ArmLiveProcess64, public ArmLinuxProcessBits
+class ArmLinuxProcess64 : public ArmProcess64, public ArmLinuxProcessBits
 {
   public:
-    ArmLinuxProcess64(LiveProcessParams * params, ObjectFile *objFile,
+    ArmLinuxProcess64(ProcessParams * params, ObjectFile *objFile,
                       ObjectFile::Arch _arch);
 
     void initState();
diff --git a/src/arch/arm/linux/process.cc b/src/arch/arm/linux/process.cc
--- a/src/arch/arm/linux/process.cc
+++ b/src/arch/arm/linux/process.cc
@@ -61,7 +61,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc32(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc32(SyscallDesc *desc, int callnum, Process *process,
             ThreadContext *tc)
 {
     int index = 0;
@@ -79,7 +79,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc64(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc64(SyscallDesc *desc, int callnum, Process *process,
             ThreadContext *tc)
 {
     int index = 0;
@@ -97,7 +97,7 @@
 
 /// Target set_tls() handler.
 static SyscallReturn
-setTLSFunc32(SyscallDesc *desc, int callnum, LiveProcess *process,
+setTLSFunc32(SyscallDesc *desc, int callnum, Process *process,
              ThreadContext *tc)
 {
     int index = 0;
@@ -110,7 +110,7 @@
 }
 
 static SyscallReturn
-setTLSFunc64(SyscallDesc *desc, int callnum, LiveProcess *process,
+setTLSFunc64(SyscallDesc *desc, int callnum, Process *process,
              ThreadContext *tc)
 {
     int index = 0;
@@ -1589,9 +1589,9 @@
     /*  5 */ SyscallDesc("set_tls", setTLSFunc64)
 };
 
-ArmLinuxProcess32::ArmLinuxProcess32(LiveProcessParams * params,
+ArmLinuxProcess32::ArmLinuxProcess32(ProcessParams * params,
         ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess32(params, objFile, _arch)
+    : ArmProcess32(params, objFile, _arch)
 {
     SyscallTable table;
 
@@ -1608,9 +1608,9 @@
     syscallTables.push_back(table);
 }
 
-ArmLinuxProcess64::ArmLinuxProcess64(LiveProcessParams * params,
+ArmLinuxProcess64::ArmLinuxProcess64(ProcessParams * params,
         ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess64(params, objFile, _arch)
+    : ArmProcess64(params, objFile, _arch)
 {
     SyscallTable table;
 
@@ -1667,7 +1667,7 @@
 void
 ArmLinuxProcess32::initState()
 {
-    ArmLiveProcess32::initState();
+    ArmProcess32::initState();
     allocateMem(commPage, PageBytes);
     ThreadContext *tc = system->getThreadContext(contextIds[0]);
 
@@ -1714,6 +1714,6 @@
 void
 ArmLinuxProcess64::initState()
 {
-    ArmLiveProcess64::initState();
+    ArmProcess64::initState();
     // The 64 bit equivalent of the comm page would be set up here.
 }
diff --git a/src/arch/arm/process.hh b/src/arch/arm/process.hh
--- a/src/arch/arm/process.hh
+++ b/src/arch/arm/process.hh
@@ -51,25 +51,23 @@
 #include "mem/page_table.hh"
 #include "sim/process.hh"
 
-class LiveProcess;
 class ObjectFile;
-class System;
 
-class ArmLiveProcess : public LiveProcess
+class ArmProcess : public Process
 {
   protected:
     ObjectFile::Arch arch;
-    ArmLiveProcess(LiveProcessParams * params, ObjectFile *objFile,
-                   ObjectFile::Arch _arch);
+    ArmProcess(ProcessParams * params, ObjectFile *objFile,
+               ObjectFile::Arch _arch);
     template<class IntType>
     void argsInit(int pageSize, ArmISA::IntRegIndex spIndex);
 };
 
-class ArmLiveProcess32 : public ArmLiveProcess
+class ArmProcess32 : public ArmProcess
 {
   protected:
-    ArmLiveProcess32(LiveProcessParams * params, ObjectFile *objFile,
-                     ObjectFile::Arch _arch);
+    ArmProcess32(ProcessParams * params, ObjectFile *objFile,
+                 ObjectFile::Arch _arch);
 
     void initState();
 
@@ -81,11 +79,11 @@
     void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
 };
 
-class ArmLiveProcess64 : public ArmLiveProcess
+class ArmProcess64 : public ArmProcess
 {
   protected:
-    ArmLiveProcess64(LiveProcessParams * params, ObjectFile *objFile,
-                     ObjectFile::Arch _arch);
+    ArmProcess64(ProcessParams * params, ObjectFile *objFile,
+                 ObjectFile::Arch _arch);
 
     void initState();
 
diff --git a/src/arch/arm/process.cc b/src/arch/arm/process.cc
--- a/src/arch/arm/process.cc
+++ b/src/arch/arm/process.cc
@@ -59,15 +59,15 @@
 using namespace std;
 using namespace ArmISA;
 
-ArmLiveProcess::ArmLiveProcess(LiveProcessParams *params, ObjectFile *objFile,
-                               ObjectFile::Arch _arch)
-    : LiveProcess(params, objFile), arch(_arch)
+ArmProcess::ArmProcess(ProcessParams *params, ObjectFile *objFile,
+                       ObjectFile::Arch _arch)
+    : Process(params, objFile), arch(_arch)
 {
 }
 
-ArmLiveProcess32::ArmLiveProcess32(LiveProcessParams *params,
-                                   ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess(params, objFile, _arch)
+ArmProcess32::ArmProcess32(ProcessParams *params, ObjectFile *objFile,
+                           ObjectFile::Arch _arch)
+    : ArmProcess(params, objFile, _arch)
 {
     stack_base = 0xbf000000L;
 
@@ -82,9 +82,9 @@
     mmap_end = 0x40000000L;
 }
 
-ArmLiveProcess64::ArmLiveProcess64(LiveProcessParams *params,
-                                   ObjectFile *objFile, ObjectFile::Arch _arch)
-    : ArmLiveProcess(params, objFile, _arch)
+ArmProcess64::ArmProcess64(ProcessParams *params, ObjectFile *objFile,
+                           ObjectFile::Arch _arch)
+    : ArmProcess(params, objFile, _arch)
 {
     stack_base = 0x7fffff0000L;
 
@@ -100,9 +100,9 @@
 }
 
 void
-ArmLiveProcess32::initState()
+ArmProcess32::initState()
 {
-    LiveProcess::initState();
+    Process::initState();
     argsInit<uint32_t>(PageBytes, INTREG_SP);
     for (int i = 0; i < contextIds.size(); i++) {
         ThreadContext * tc = system->getThreadContext(contextIds[i]);
@@ -119,9 +119,9 @@
 }
 
 void
-ArmLiveProcess64::initState()
+ArmProcess64::initState()
 {
-    LiveProcess::initState();
+    Process::initState();
     argsInit<uint64_t>(PageBytes, INTREG_SP0);
     for (int i = 0; i < contextIds.size(); i++) {
         ThreadContext * tc = system->getThreadContext(contextIds[i]);
@@ -142,7 +142,7 @@
 
 template <class IntType>
 void
-ArmLiveProcess::argsInit(int pageSize, IntRegIndex spIndex)
+ArmProcess::argsInit(int pageSize, IntRegIndex spIndex)
 {
     int intSize = sizeof(IntType);
 
@@ -405,21 +405,21 @@
 }
 
 ArmISA::IntReg
-ArmLiveProcess32::getSyscallArg(ThreadContext *tc, int &i)
+ArmProcess32::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 6);
     return tc->readIntReg(ArgumentReg0 + i++);
 }
 
 ArmISA::IntReg
-ArmLiveProcess64::getSyscallArg(ThreadContext *tc, int &i)
+ArmProcess64::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 8);
     return tc->readIntReg(ArgumentReg0 + i++);
 }
 
 ArmISA::IntReg
-ArmLiveProcess32::getSyscallArg(ThreadContext *tc, int &i, int width)
+ArmProcess32::getSyscallArg(ThreadContext *tc, int &i, int width)
 {
     assert(width == 32 || width == 64);
     if (width == 32)
@@ -438,29 +438,28 @@
 }
 
 ArmISA::IntReg
-ArmLiveProcess64::getSyscallArg(ThreadContext *tc, int &i, int width)
+ArmProcess64::getSyscallArg(ThreadContext *tc, int &i, int width)
 {
     return getSyscallArg(tc, i);
 }
 
 
 void
-ArmLiveProcess32::setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val)
+ArmProcess32::setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val)
 {
     assert(i < 6);
     tc->setIntReg(ArgumentReg0 + i, val);
 }
 
 void
-ArmLiveProcess64::setSyscallArg(ThreadContext *tc,
-        int i, ArmISA::IntReg val)
+ArmProcess64::setSyscallArg(ThreadContext *tc, int i, ArmISA::IntReg val)
 {
     assert(i < 8);
     tc->setIntReg(ArgumentReg0 + i, val);
 }
 
 void
-ArmLiveProcess32::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+ArmProcess32::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
 
     if (objFile->getOpSys() == ObjectFile::FreeBSD) {
@@ -477,7 +476,7 @@
 }
 
 void
-ArmLiveProcess64::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+ArmProcess64::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
 
     if (objFile->getOpSys() == ObjectFile::FreeBSD) {
diff --git a/src/arch/mips/linux/process.hh b/src/arch/mips/linux/process.hh
--- a/src/arch/mips/linux/process.hh
+++ b/src/arch/mips/linux/process.hh
@@ -37,11 +37,11 @@
 #include "sim/eventq.hh"
 
 /// A process with emulated Mips/Linux syscalls.
-class MipsLinuxProcess : public MipsLiveProcess
+class MipsLinuxProcess : public MipsProcess
 {
   public:
     /// Constructor.
-    MipsLinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    MipsLinuxProcess(ProcessParams * params, ObjectFile *objFile);
 
     virtual SyscallDesc* getDesc(int callnum);
 
diff --git a/src/arch/mips/linux/process.cc b/src/arch/mips/linux/process.cc
--- a/src/arch/mips/linux/process.cc
+++ b/src/arch/mips/linux/process.cc
@@ -49,7 +49,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -69,7 +69,7 @@
 /// borrowed from Tru64, the subcases that get used appear to be
 /// different in practice from those used by Tru64 processes.
 static SyscallReturn
-sys_getsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+sys_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                    ThreadContext *tc)
 {
     int index = 0;
@@ -98,7 +98,7 @@
 
 /// Target sys_setsysinfo() handler.
 static SyscallReturn
-sys_setsysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+sys_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
                    ThreadContext *tc)
 {
     int index = 0;
@@ -128,7 +128,7 @@
 }
 
 static SyscallReturn
-setThreadAreaFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+setThreadAreaFunc(SyscallDesc *desc, int callnum, Process *process,
                   ThreadContext *tc)
 {
     int index = 0;
@@ -460,10 +460,10 @@
     /* 319 */ SyscallDesc("eventfd", unimplementedFunc)
 };
 
-MipsLinuxProcess::MipsLinuxProcess(LiveProcessParams * params,
-                                     ObjectFile *objFile)
-    : MipsLiveProcess(params, objFile),
-     Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
+MipsLinuxProcess::MipsLinuxProcess(ProcessParams * params,
+                                   ObjectFile *objFile)
+    : MipsProcess(params, objFile),
+      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {  }
 
 SyscallDesc*
diff --git a/src/arch/mips/process.hh b/src/arch/mips/process.hh
--- a/src/arch/mips/process.hh
+++ b/src/arch/mips/process.hh
@@ -38,14 +38,12 @@
 #include "mem/page_table.hh"
 #include "sim/process.hh"
 
-class LiveProcess;
 class ObjectFile;
-class System;
 
-class MipsLiveProcess : public LiveProcess
+class MipsProcess : public Process
 {
   protected:
-    MipsLiveProcess(LiveProcessParams * params, ObjectFile *objFile);
+    MipsProcess(ProcessParams * params, ObjectFile *objFile);
 
     void initState();
 
@@ -55,7 +53,7 @@
   public:
     MipsISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
     void setSyscallArg(ThreadContext *tc, int i, MipsISA::IntReg val);
     void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
 };
diff --git a/src/arch/mips/process.cc b/src/arch/mips/process.cc
--- a/src/arch/mips/process.cc
+++ b/src/arch/mips/process.cc
@@ -47,9 +47,8 @@
 using namespace std;
 using namespace MipsISA;
 
-MipsLiveProcess::MipsLiveProcess(LiveProcessParams * params,
-        ObjectFile *objFile)
-    : LiveProcess(params, objFile)
+MipsProcess::MipsProcess(ProcessParams * params, ObjectFile *objFile)
+    : Process(params, objFile)
 {
     // Set up stack. On MIPS, stack starts at the top of kuseg
     // user address space. MIPS stack grows down from here
@@ -67,16 +66,16 @@
 }
 
 void
-MipsLiveProcess::initState()
+MipsProcess::initState()
 {
-    LiveProcess::initState();
+    Process::initState();
 
     argsInit<uint32_t>(PageBytes);
 }
 
 template<class IntType>
 void
-MipsLiveProcess::argsInit(int pageSize)
+MipsProcess::argsInit(int pageSize)
 {
     int intSize = sizeof(IntType);
 
@@ -191,22 +190,21 @@
 
 
 MipsISA::IntReg
-MipsLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+MipsProcess::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 6);
     return tc->readIntReg(FirstArgumentReg + i++);
 }
 
 void
-MipsLiveProcess::setSyscallArg(ThreadContext *tc,
-        int i, MipsISA::IntReg val)
+MipsProcess::setSyscallArg(ThreadContext *tc, int i, MipsISA::IntReg val)
 {
     assert(i < 6);
     tc->setIntReg(FirstArgumentReg + i, val);
 }
 
 void
-MipsLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+MipsProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
     if (sysret.successful()) {
         // no error
diff --git a/src/arch/power/linux/process.hh b/src/arch/power/linux/process.hh
--- a/src/arch/power/linux/process.hh
+++ b/src/arch/power/linux/process.hh
@@ -36,10 +36,10 @@
 #include "arch/power/process.hh"
 
 /// A process with emulated PPC/Linux syscalls.
-class PowerLinuxProcess : public PowerLiveProcess
+class PowerLinuxProcess : public PowerProcess
 {
   public:
-    PowerLinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    PowerLinuxProcess(ProcessParams * params, ObjectFile *objFile);
 
     virtual SyscallDesc* getDesc(int callnum);
 
@@ -47,7 +47,7 @@
 
     PowerISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
     void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val);
 
     /// Array of syscall descriptors, indexed by call number.
diff --git a/src/arch/power/linux/process.cc b/src/arch/power/linux/process.cc
--- a/src/arch/power/linux/process.cc
+++ b/src/arch/power/linux/process.cc
@@ -49,7 +49,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -415,10 +415,10 @@
     /* 346 */ SyscallDesc("epoll_pwait", unimplementedFunc),
 };
 
-PowerLinuxProcess::PowerLinuxProcess(LiveProcessParams * params,
+PowerLinuxProcess::PowerLinuxProcess(ProcessParams * params,
         ObjectFile *objFile)
-    : PowerLiveProcess(params, objFile),
-     Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
+    : PowerProcess(params, objFile),
+      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
 }
 
@@ -434,7 +434,7 @@
 void
 PowerLinuxProcess::initState()
 {
-    PowerLiveProcess::initState();
+    PowerProcess::initState();
 }
 
 PowerISA::IntReg
diff --git a/src/arch/power/process.hh b/src/arch/power/process.hh
--- a/src/arch/power/process.hh
+++ b/src/arch/power/process.hh
@@ -39,14 +39,12 @@
 #include "mem/page_table.hh"
 #include "sim/process.hh"
 
-class LiveProcess;
 class ObjectFile;
-class System;
 
-class PowerLiveProcess : public LiveProcess
+class PowerProcess : public Process
 {
   protected:
-    PowerLiveProcess(LiveProcessParams * params, ObjectFile *objFile);
+    PowerProcess(ProcessParams * params, ObjectFile *objFile);
 
     void initState();
 
@@ -54,7 +52,7 @@
     void argsInit(int intSize, int pageSize);
     PowerISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
     void setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val);
     void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
 };
diff --git a/src/arch/power/process.cc b/src/arch/power/process.cc
--- a/src/arch/power/process.cc
+++ b/src/arch/power/process.cc
@@ -47,9 +47,8 @@
 using namespace std;
 using namespace PowerISA;
 
-PowerLiveProcess::PowerLiveProcess(LiveProcessParams *params,
-        ObjectFile *objFile)
-    : LiveProcess(params, objFile)
+PowerProcess::PowerProcess(ProcessParams *params, ObjectFile *objFile)
+    : Process(params, objFile)
 {
     stack_base = 0xbf000000L;
 
@@ -65,7 +64,7 @@
 }
 
 void
-PowerLiveProcess::initState()
+PowerProcess::initState()
 {
     Process::initState();
 
@@ -73,7 +72,7 @@
 }
 
 void
-PowerLiveProcess::argsInit(int intSize, int pageSize)
+PowerProcess::argsInit(int intSize, int pageSize)
 {
     typedef AuxVector<uint32_t> auxv_t;
     std::vector<auxv_t> auxv;
@@ -266,22 +265,21 @@
 }
 
 PowerISA::IntReg
-PowerLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+PowerProcess::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 5);
     return tc->readIntReg(ArgumentReg0 + i++);
 }
 
 void
-PowerLiveProcess::setSyscallArg(ThreadContext *tc,
-        int i, PowerISA::IntReg val)
+PowerProcess::setSyscallArg(ThreadContext *tc, int i, PowerISA::IntReg val)
 {
     assert(i < 5);
     tc->setIntReg(ArgumentReg0 + i, val);
 }
 
 void
-PowerLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+PowerProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
     Cr cr = tc->readIntReg(INTREG_CR);
     if (sysret.successful()) {
diff --git a/src/arch/sparc/faults.cc b/src/arch/sparc/faults.cc
--- a/src/arch/sparc/faults.cc
+++ b/src/arch/sparc/faults.cc
@@ -670,12 +670,11 @@
 
     Process *p = tc->getProcessPtr();
 
-    //XXX This will only work in faults from a SparcLiveProcess
-    SparcLiveProcess *lp = dynamic_cast<SparcLiveProcess *>(p);
-    assert(lp);
+    SparcProcess *sp = dynamic_cast<SparcProcess *>(p);
+    assert(sp);
 
     // Then adjust the PC and NPC
-    tc->pcState(lp->readSpillStart());
+    tc->pcState(sp->readSpillStart());
 }
 
 void
@@ -690,12 +689,11 @@
 
     Process *p = tc->getProcessPtr();
 
-    //XXX This will only work in faults from a SparcLiveProcess
-    SparcLiveProcess *lp = dynamic_cast<SparcLiveProcess *>(p);
-    assert(lp);
+    SparcProcess *sp = dynamic_cast<SparcProcess *>(p);
+    assert(sp);
 
     // Then adjust the PC and NPC
-    tc->pcState(lp->readFillStart());
+    tc->pcState(sp->readFillStart());
 }
 
 void
@@ -712,10 +710,10 @@
 
     Process *p = tc->getProcessPtr();
 
-    SparcLiveProcess *lp = dynamic_cast<SparcLiveProcess *>(p);
-    assert(lp);
+    SparcProcess *sp = dynamic_cast<SparcProcess *>(p);
+    assert(sp);
 
-    lp->handleTrap(_n, tc);
+    sp->handleTrap(_n, tc);
 
     // We need to explicitly advance the pc, since that's not done for us
     // on a faulting instruction
diff --git a/src/arch/sparc/linux/process.hh b/src/arch/sparc/linux/process.hh
--- a/src/arch/sparc/linux/process.hh
+++ b/src/arch/sparc/linux/process.hh
@@ -58,11 +58,11 @@
 };
 
 /// A process with emulated SPARC/Linux syscalls.
-class Sparc32LinuxProcess : public SparcLinuxProcess, public Sparc32LiveProcess
+class Sparc32LinuxProcess : public SparcLinuxProcess, public Sparc32Process
 {
   public:
     /// Constructor.
-    Sparc32LinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    Sparc32LinuxProcess(ProcessParams * params, ObjectFile *objFile);
 
     SyscallDesc*
     getDesc(int callnum)
@@ -74,11 +74,11 @@
 };
 
 /// A process with emulated 32 bit SPARC/Linux syscalls.
-class Sparc64LinuxProcess : public SparcLinuxProcess, public Sparc64LiveProcess
+class Sparc64LinuxProcess : public SparcLinuxProcess, public Sparc64Process
 {
   public:
     /// Constructor.
-    Sparc64LinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    Sparc64LinuxProcess(ProcessParams * params, ObjectFile *objFile);
 
     SyscallDesc*
     getDesc(int callnum)
@@ -90,7 +90,7 @@
 };
 
 SyscallReturn getresuidFunc(SyscallDesc *desc, int num,
-                                 LiveProcess *p, ThreadContext *tc);
+                            Process *p, ThreadContext *tc);
 
 } // namespace SparcISA
 #endif // __SPARC_LINUX_PROCESS_HH__
diff --git a/src/arch/sparc/linux/process.cc b/src/arch/sparc/linux/process.cc
--- a/src/arch/sparc/linux/process.cc
+++ b/src/arch/sparc/linux/process.cc
@@ -60,9 +60,9 @@
     return &syscall32Descs[callnum];
 }
 
-Sparc32LinuxProcess::Sparc32LinuxProcess(LiveProcessParams * params,
+Sparc32LinuxProcess::Sparc32LinuxProcess(ProcessParams * params,
                                          ObjectFile *objFile)
-    : Sparc32LiveProcess(params, objFile)
+    : Sparc32Process(params, objFile)
 {}
 
 void Sparc32LinuxProcess::handleTrap(int trapNum, ThreadContext *tc)
@@ -72,13 +72,13 @@
         tc->syscall(tc->readIntReg(1));
         break;
       default:
-        SparcLiveProcess::handleTrap(trapNum, tc);
+        SparcProcess::handleTrap(trapNum, tc);
     }
 }
 
-Sparc64LinuxProcess::Sparc64LinuxProcess(LiveProcessParams * params,
+Sparc64LinuxProcess::Sparc64LinuxProcess(ProcessParams * params,
                                          ObjectFile *objFile)
-    : Sparc64LiveProcess(params, objFile)
+    : Sparc64Process(params, objFile)
 {}
 
 void Sparc64LinuxProcess::handleTrap(int trapNum, ThreadContext *tc)
@@ -89,6 +89,6 @@
         tc->syscall(tc->readIntReg(1));
         break;
       default:
-        SparcLiveProcess::handleTrap(trapNum, tc);
+        SparcProcess::handleTrap(trapNum, tc);
     }
 }
diff --git a/src/arch/sparc/linux/syscalls.cc b/src/arch/sparc/linux/syscalls.cc
--- a/src/arch/sparc/linux/syscalls.cc
+++ b/src/arch/sparc/linux/syscalls.cc
@@ -32,15 +32,15 @@
 #include "sim/syscall_desc.hh"
 #include "sim/syscall_emul.hh"
 
-class LiveProcess;
+class Process;
 class ThreadContext;
 
 namespace SparcISA {
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-        ThreadContext *tc)
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
+          ThreadContext *tc)
 {
     int index = 0;
     TypedBufferArg<Linux::utsname> name(process->getSyscallArg(tc, index));
@@ -58,7 +58,7 @@
 
 
 SyscallReturn
-getresuidFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+getresuidFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     const IntReg id = htog(100);
     int index = 0;
diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -40,9 +40,8 @@
 #include "sim/process.hh"
 
 class ObjectFile;
-class System;
 
-class SparcLiveProcess : public LiveProcess
+class SparcProcess : public Process
 {
   protected:
 
@@ -51,8 +50,8 @@
     // The locations of the fill and spill handlers
     Addr fillStart, spillStart;
 
-    SparcLiveProcess(LiveProcessParams * params,
-            ObjectFile *objFile, Addr _StackBias);
+    SparcProcess(ProcessParams * params, ObjectFile *objFile,
+                 Addr _StackBias);
 
     void initState();
 
@@ -71,12 +70,12 @@
     void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
 };
 
-class Sparc32LiveProcess : public SparcLiveProcess
+class Sparc32Process : public SparcProcess
 {
   protected:
 
-    Sparc32LiveProcess(LiveProcessParams * params, ObjectFile *objFile) :
-            SparcLiveProcess(params, objFile, 0)
+    Sparc32Process(ProcessParams * params, ObjectFile *objFile) :
+        SparcProcess(params, objFile, 0)
     {
         // Set up stack. On SPARC Linux, stack goes from the top of memory
         // downward, less the hole for the kernel address space.
@@ -96,17 +95,17 @@
 
     SparcISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
 
     void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val);
 };
 
-class Sparc64LiveProcess : public SparcLiveProcess
+class Sparc64Process : public SparcProcess
 {
   protected:
 
-    Sparc64LiveProcess(LiveProcessParams * params, ObjectFile *objFile) :
-            SparcLiveProcess(params, objFile, 2047)
+    Sparc64Process(ProcessParams * params, ObjectFile *objFile) :
+        SparcProcess(params, objFile, 2047)
     {
         // Set up stack. On SPARC Linux, stack goes from the top of memory
         // downward, less the hole for the kernel address space.
@@ -126,7 +125,7 @@
 
     SparcISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
     /// Explicitly import the otherwise hidden getSyscallArg
-    using LiveProcess::getSyscallArg;
+    using Process::getSyscallArg;
 
     void setSyscallArg(ThreadContext *tc, int i, SparcISA::IntReg val);
 };
diff --git a/src/arch/sparc/process.cc b/src/arch/sparc/process.cc
--- a/src/arch/sparc/process.cc
+++ b/src/arch/sparc/process.cc
@@ -52,9 +52,9 @@
 static const int FirstArgumentReg = 8;
 
 
-SparcLiveProcess::SparcLiveProcess(LiveProcessParams * params,
-        ObjectFile *objFile, Addr _StackBias)
-    : LiveProcess(params, objFile), StackBias(_StackBias)
+SparcProcess::SparcProcess(ProcessParams * params, ObjectFile *objFile,
+                           Addr _StackBias)
+    : Process(params, objFile), StackBias(_StackBias)
 {
 
     // XXX all the below need to be updated for SPARC - Ali
@@ -70,7 +70,7 @@
 }
 
 void
-SparcLiveProcess::handleTrap(int trapNum, ThreadContext *tc)
+SparcProcess::handleTrap(int trapNum, ThreadContext *tc)
 {
     PCState pc = tc->pcState();
     switch (trapNum) {
@@ -111,9 +111,9 @@
 }
 
 void
-SparcLiveProcess::initState()
+SparcProcess::initState()
 {
-    LiveProcess::initState();
+    Process::initState();
 
     ThreadContext *tc = system->getThreadContext(contextIds[0]);
     // From the SPARC ABI
@@ -157,9 +157,9 @@
 }
 
 void
-Sparc32LiveProcess::initState()
+Sparc32Process::initState()
 {
-    SparcLiveProcess::initState();
+    SparcProcess::initState();
 
     ThreadContext *tc = system->getThreadContext(contextIds[0]);
     // The process runs in user mode with 32 bit addresses
@@ -172,9 +172,9 @@
 }
 
 void
-Sparc64LiveProcess::initState()
+Sparc64Process::initState()
 {
-    SparcLiveProcess::initState();
+    SparcProcess::initState();
 
     ThreadContext *tc = system->getThreadContext(contextIds[0]);
     // The process runs in user mode
@@ -187,7 +187,7 @@
 
 template<class IntType>
 void
-SparcLiveProcess::argsInit(int pageSize)
+SparcProcess::argsInit(int pageSize)
 {
     int intSize = sizeof(IntType);
 
@@ -416,9 +416,9 @@
 }
 
 void
-Sparc64LiveProcess::argsInit(int intSize, int pageSize)
+Sparc64Process::argsInit(int intSize, int pageSize)
 {
-    SparcLiveProcess::argsInit<uint64_t>(pageSize);
+    SparcProcess::argsInit<uint64_t>(pageSize);
 
     // Stuff the trap handlers into the process address space
     initVirtMem.writeBlob(fillStart,
@@ -428,9 +428,9 @@
 }
 
 void
-Sparc32LiveProcess::argsInit(int intSize, int pageSize)
+Sparc32Process::argsInit(int intSize, int pageSize)
 {
-    SparcLiveProcess::argsInit<uint32_t>(pageSize);
+    SparcProcess::argsInit<uint32_t>(pageSize);
 
     // Stuff the trap handlers into the process address space
     initVirtMem.writeBlob(fillStart,
@@ -439,7 +439,7 @@
             (uint8_t*)spillHandler32, sizeof(MachInst) *  numSpillInsts);
 }
 
-void Sparc32LiveProcess::flushWindows(ThreadContext *tc)
+void Sparc32Process::flushWindows(ThreadContext *tc)
 {
     IntReg Cansave = tc->readIntReg(NumIntArchRegs + 3);
     IntReg Canrestore = tc->readIntReg(NumIntArchRegs + 4);
@@ -474,7 +474,7 @@
 }
 
 void
-Sparc64LiveProcess::flushWindows(ThreadContext *tc)
+Sparc64Process::flushWindows(ThreadContext *tc)
 {
     IntReg Cansave = tc->readIntReg(NumIntArchRegs + 3);
     IntReg Canrestore = tc->readIntReg(NumIntArchRegs + 4);
@@ -509,35 +509,35 @@
 }
 
 IntReg
-Sparc32LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+Sparc32Process::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 6);
     return bits(tc->readIntReg(FirstArgumentReg + i++), 31, 0);
 }
 
 void
-Sparc32LiveProcess::setSyscallArg(ThreadContext *tc, int i, IntReg val)
+Sparc32Process::setSyscallArg(ThreadContext *tc, int i, IntReg val)
 {
     assert(i < 6);
     tc->setIntReg(FirstArgumentReg + i, bits(val, 31, 0));
 }
 
 IntReg
-Sparc64LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+Sparc64Process::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < 6);
     return tc->readIntReg(FirstArgumentReg + i++);
 }
 
 void
-Sparc64LiveProcess::setSyscallArg(ThreadContext *tc, int i, IntReg val)
+Sparc64Process::setSyscallArg(ThreadContext *tc, int i, IntReg val)
 {
     assert(i < 6);
     tc->setIntReg(FirstArgumentReg + i, val);
 }
 
 void
-SparcLiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
+SparcProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn sysret)
 {
     // check for error condition.  SPARC syscall convention is to
     // indicate success/failure in reg the carry bit of the ccr
diff --git a/src/arch/sparc/solaris/process.hh b/src/arch/sparc/solaris/process.hh
--- a/src/arch/sparc/solaris/process.hh
+++ b/src/arch/sparc/solaris/process.hh
@@ -38,11 +38,11 @@
 namespace SparcISA {
 
 /// A process with emulated SPARC/Solaris syscalls.
-class SparcSolarisProcess : public Sparc64LiveProcess
+class SparcSolarisProcess : public Sparc64Process
 {
   public:
     /// Constructor.
-    SparcSolarisProcess(LiveProcessParams * params, ObjectFile *objFile);
+    SparcSolarisProcess(ProcessParams * params, ObjectFile *objFile);
 
     virtual SyscallDesc* getDesc(int callnum);
 
diff --git a/src/arch/sparc/solaris/process.cc b/src/arch/sparc/solaris/process.cc
--- a/src/arch/sparc/solaris/process.cc
+++ b/src/arch/sparc/solaris/process.cc
@@ -45,7 +45,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -322,9 +322,9 @@
     /* 255 */ SyscallDesc("umount2", unimplementedFunc)
 };
 
-SparcSolarisProcess::SparcSolarisProcess(LiveProcessParams * params,
-                                     ObjectFile *objFile)
-    : Sparc64LiveProcess(params, objFile),
+SparcSolarisProcess::SparcSolarisProcess(ProcessParams * params,
+                                         ObjectFile *objFile)
+    : Sparc64Process(params, objFile),
      Num_Syscall_Descs(sizeof(syscallDescs) / sizeof(SyscallDesc))
 {
     // The sparc syscall table must be <= 284 entries because that is all there
diff --git a/src/arch/x86/linux/process.hh b/src/arch/x86/linux/process.hh
--- a/src/arch/x86/linux/process.hh
+++ b/src/arch/x86/linux/process.hh
@@ -46,18 +46,18 @@
 
 namespace X86ISA {
 
-class X86_64LinuxProcess : public X86_64LiveProcess
+class X86_64LinuxProcess : public X86_64Process
 {
   public:
     /// Constructor.
-    X86_64LinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    X86_64LinuxProcess(ProcessParams * params, ObjectFile *objFile);
 };
 
-class I386LinuxProcess : public I386LiveProcess
+class I386LinuxProcess : public I386Process
 {
   public:
     /// Constructor.
-    I386LinuxProcess(LiveProcessParams * params, ObjectFile *objFile);
+    I386LinuxProcess(ProcessParams * params, ObjectFile *objFile);
 };
 
 } // namespace X86ISA
diff --git a/src/arch/x86/linux/process.cc b/src/arch/x86/linux/process.cc
--- a/src/arch/x86/linux/process.cc
+++ b/src/arch/x86/linux/process.cc
@@ -54,7 +54,7 @@
 
 /// Target uname() handler.
 static SyscallReturn
-unameFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unameFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -72,7 +72,7 @@
 }
 
 static SyscallReturn
-archPrctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+archPrctlFunc(SyscallDesc *desc, int callnum, Process *process,
               ThreadContext *tc)
 {
     enum ArchPrctlCodes
@@ -139,22 +139,22 @@
 
 static SyscallReturn
 setThreadArea32Func(SyscallDesc *desc, int callnum,
-        LiveProcess *process, ThreadContext *tc)
+                    Process *process, ThreadContext *tc)
 {
     const int minTLSEntry = 6;
     const int numTLSEntries = 3;
     const int maxTLSEntry = minTLSEntry + numTLSEntries - 1;
 
-    X86LiveProcess *x86lp = dynamic_cast<X86LiveProcess *>(process);
-    assert(x86lp);
+    X86Process *x86p = dynamic_cast<X86Process *>(process);
+    assert(x86p);
 
-    assert((maxTLSEntry + 1) * sizeof(uint64_t) <= x86lp->gdtSize());
+    assert((maxTLSEntry + 1) * sizeof(uint64_t) <= x86p->gdtSize());
 
     int argIndex = 0;
     TypedBufferArg<UserDesc32> userDesc(process->getSyscallArg(tc, argIndex));
     TypedBufferArg<uint64_t>
-        gdt(x86lp->gdtStart() + minTLSEntry * sizeof(uint64_t),
-                numTLSEntries * sizeof(uint64_t));
+        gdt(x86p->gdtStart() + minTLSEntry * sizeof(uint64_t),
+            numTLSEntries * sizeof(uint64_t));
 
     if (!userDesc.copyIn(tc->getMemProxy()))
         return -EFAULT;
@@ -536,10 +536,10 @@
     /* 313 */ SyscallDesc("finit_module", unimplementedFunc),
 };
 
-X86_64LinuxProcess::X86_64LinuxProcess(LiveProcessParams * params,
-        ObjectFile *objFile)
-    : X86_64LiveProcess(params, objFile, syscallDescs64,
-                        sizeof(syscallDescs64) / sizeof(SyscallDesc))
+X86_64LinuxProcess::X86_64LinuxProcess(ProcessParams * params,
+                                       ObjectFile *objFile)
+    : X86_64Process(params, objFile, syscallDescs64,
+                    sizeof(syscallDescs64) / sizeof(SyscallDesc))
 {}
 
 static SyscallDesc syscallDescs32[] = {
@@ -869,8 +869,7 @@
     /* 323 */ SyscallDesc("eventfd", unimplementedFunc)
 };
 
-I386LinuxProcess::I386LinuxProcess(LiveProcessParams * params,
-        ObjectFile *objFile)
-    : I386LiveProcess(params, objFile, syscallDescs32,
-                      sizeof(syscallDescs32) / sizeof(SyscallDesc))
+I386LinuxProcess::I386LinuxProcess(ProcessParams * params, ObjectFile *objFile)
+    : I386Process(params, objFile, syscallDescs32,
+                  sizeof(syscallDescs32) / sizeof(SyscallDesc))
 {}
diff --git a/src/arch/x86/process.hh b/src/arch/x86/process.hh
--- a/src/arch/x86/process.hh
+++ b/src/arch/x86/process.hh
@@ -55,7 +55,7 @@
         M5_AT_SYSINFO_EHDR = 33
     };
 
-    class X86LiveProcess : public LiveProcess
+    class X86Process : public Process
     {
       protected:
         Addr _gdtStart;
@@ -64,8 +64,8 @@
         SyscallDesc *syscallDescs;
         const int numSyscallDescs;
 
-        X86LiveProcess(LiveProcessParams * params, ObjectFile *objFile,
-                SyscallDesc *_syscallDescs, int _numSyscallDescs);
+        X86Process(ProcessParams * params, ObjectFile *objFile,
+                   SyscallDesc *_syscallDescs, int _numSyscallDescs);
 
         template<class IntType>
         void argsInit(int pageSize,
@@ -83,11 +83,11 @@
         void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
     };
 
-    class X86_64LiveProcess : public X86LiveProcess
+    class X86_64Process : public X86Process
     {
       protected:
-        X86_64LiveProcess(LiveProcessParams *params, ObjectFile *objFile,
-                SyscallDesc *_syscallDescs, int _numSyscallDescs);
+        X86_64Process(ProcessParams *params, ObjectFile *objFile,
+                      SyscallDesc *_syscallDescs, int _numSyscallDescs);
 
         class VSyscallPage
         {
@@ -105,15 +105,15 @@
 
         X86ISA::IntReg getSyscallArg(ThreadContext *tc, int &i);
         /// Explicitly import the otherwise hidden getSyscallArg
-        using LiveProcess::getSyscallArg;
+        using Process::getSyscallArg;
         void setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val);
     };
 
-    class I386LiveProcess : public X86LiveProcess
+    class I386Process : public X86Process
     {
       protected:
-        I386LiveProcess(LiveProcessParams *params, ObjectFile *objFile,
-                SyscallDesc *_syscallDescs, int _numSyscallDescs);
+        I386Process(ProcessParams *params, ObjectFile *objFile,
+                    SyscallDesc *_syscallDescs, int _numSyscallDescs);
 
         class VSyscallPage
         {
diff --git a/src/arch/x86/process.cc b/src/arch/x86/process.cc
--- a/src/arch/x86/process.cc
+++ b/src/arch/x86/process.cc
@@ -86,19 +86,18 @@
 };
 static const int NumArgumentRegs32 = sizeof(ArgumentReg) / sizeof(const int);
 
-X86LiveProcess::X86LiveProcess(LiveProcessParams * params, ObjectFile *objFile,
-        SyscallDesc *_syscallDescs, int _numSyscallDescs) :
-    LiveProcess(params, objFile), syscallDescs(_syscallDescs),
-    numSyscallDescs(_numSyscallDescs)
+X86Process::X86Process(ProcessParams * params, ObjectFile *objFile,
+                       SyscallDesc *_syscallDescs, int _numSyscallDescs)
+    : Process(params, objFile), syscallDescs(_syscallDescs),
+      numSyscallDescs(_numSyscallDescs)
 {
     brk_point = objFile->dataBase() + objFile->dataSize() + objFile->bssSize();
     brk_point = roundUp(brk_point, PageBytes);
 }
 
-X86_64LiveProcess::X86_64LiveProcess(LiveProcessParams *params,
-        ObjectFile *objFile, SyscallDesc *_syscallDescs,
-        int _numSyscallDescs) :
-    X86LiveProcess(params, objFile, _syscallDescs, _numSyscallDescs)
+X86_64Process::X86_64Process(ProcessParams *params, ObjectFile *objFile,
+                             SyscallDesc *_syscallDescs, int _numSyscallDescs)
+    : X86Process(params, objFile, _syscallDescs, _numSyscallDescs)
 {
 
     vsyscallPage.base = 0xffffffffff600000ULL;
@@ -126,7 +125,7 @@
 }
 
 void
-I386LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
+I386Process::syscall(int64_t callnum, ThreadContext *tc)
 {
     TheISA::PCState pc = tc->pcState();
     Addr eip = pc.pc();
@@ -135,14 +134,13 @@
         pc.npc(vsyscallPage.base + vsyscallPage.vsysexitOffset);
         tc->pcState(pc);
     }
-    X86LiveProcess::syscall(callnum, tc);
+    X86Process::syscall(callnum, tc);
 }
 
 
-I386LiveProcess::I386LiveProcess(LiveProcessParams *params,
-        ObjectFile *objFile, SyscallDesc *_syscallDescs,
-        int _numSyscallDescs) :
-    X86LiveProcess(params, objFile, _syscallDescs, _numSyscallDescs)
+I386Process::I386Process(ProcessParams *params, ObjectFile *objFile,
+                         SyscallDesc *_syscallDescs, int _numSyscallDescs)
+    : X86Process(params, objFile, _syscallDescs, _numSyscallDescs)
 {
     _gdtStart = ULL(0xffffd000);
     _gdtSize = PageBytes;
@@ -169,7 +167,7 @@
 }
 
 SyscallDesc*
-X86LiveProcess::getDesc(int callnum)
+X86Process::getDesc(int callnum)
 {
     if (callnum < 0 || callnum >= numSyscallDescs)
         return NULL;
@@ -177,9 +175,9 @@
 }
 
 void
-X86_64LiveProcess::initState()
+X86_64Process::initState()
 {
-    X86LiveProcess::initState();
+    X86Process::initState();
 
     argsInit(sizeof(uint64_t), PageBytes);
 
@@ -621,9 +619,9 @@
 }
 
 void
-I386LiveProcess::initState()
+I386Process::initState()
 {
-    X86LiveProcess::initState();
+    X86Process::initState();
 
     argsInit(sizeof(uint32_t), PageBytes);
 
@@ -741,7 +739,7 @@
 
 template<class IntType>
 void
-X86LiveProcess::argsInit(int pageSize,
+X86Process::argsInit(int pageSize,
         std::vector<AuxVector<IntType> > extraAuxvs)
 {
     int intSize = sizeof(IntType);
@@ -1029,16 +1027,16 @@
 }
 
 void
-X86_64LiveProcess::argsInit(int intSize, int pageSize)
+X86_64Process::argsInit(int intSize, int pageSize)
 {
     std::vector<AuxVector<uint64_t> > extraAuxvs;
     extraAuxvs.push_back(AuxVector<uint64_t>(M5_AT_SYSINFO_EHDR,
                 vsyscallPage.base));
-    X86LiveProcess::argsInit<uint64_t>(pageSize, extraAuxvs);
+    X86Process::argsInit<uint64_t>(pageSize, extraAuxvs);
 }
 
 void
-I386LiveProcess::argsInit(int intSize, int pageSize)
+I386Process::argsInit(int intSize, int pageSize)
 {
     std::vector<AuxVector<uint32_t> > extraAuxvs;
     //Tell the binary where the vsyscall part of the vsyscall page is.
@@ -1046,38 +1044,38 @@
                 vsyscallPage.base + vsyscallPage.vsyscallOffset));
     extraAuxvs.push_back(AuxVector<uint32_t>(M5_AT_SYSINFO_EHDR,
                 vsyscallPage.base));
-    X86LiveProcess::argsInit<uint32_t>(pageSize, extraAuxvs);
+    X86Process::argsInit<uint32_t>(pageSize, extraAuxvs);
 }
 
 void
-X86LiveProcess::setSyscallReturn(ThreadContext *tc, SyscallReturn retval)
+X86Process::setSyscallReturn(ThreadContext *tc, SyscallReturn retval)
 {
     tc->setIntReg(INTREG_RAX, retval.encodedValue());
 }
 
 X86ISA::IntReg
-X86_64LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+X86_64Process::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < NumArgumentRegs);
     return tc->readIntReg(ArgumentReg[i++]);
 }
 
 void
-X86_64LiveProcess::setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val)
+X86_64Process::setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val)
 {
     assert(i < NumArgumentRegs);
     return tc->setIntReg(ArgumentReg[i], val);
 }
 
 X86ISA::IntReg
-I386LiveProcess::getSyscallArg(ThreadContext *tc, int &i)
+I386Process::getSyscallArg(ThreadContext *tc, int &i)
 {
     assert(i < NumArgumentRegs32);
     return tc->readIntReg(ArgumentReg32[i++]);
 }
 
 X86ISA::IntReg
-I386LiveProcess::getSyscallArg(ThreadContext *tc, int &i, int width)
+I386Process::getSyscallArg(ThreadContext *tc, int &i, int width)
 {
     assert(width == 32 || width == 64);
     assert(i < NumArgumentRegs);
@@ -1088,7 +1086,7 @@
 }
 
 void
-I386LiveProcess::setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val)
+I386Process::setSyscallArg(ThreadContext *tc, int i, X86ISA::IntReg val)
 {
     assert(i < NumArgumentRegs);
     return tc->setIntReg(ArgumentReg[i], val);
diff --git a/src/gpu-compute/cl_driver.hh b/src/gpu-compute/cl_driver.hh
--- a/src/gpu-compute/cl_driver.hh
+++ b/src/gpu-compute/cl_driver.hh
@@ -43,7 +43,7 @@
 
 class GpuDispatcher;
 class HsaCode;
-class LiveProcess;
+class Process;
 class ThreadContext;
 
 struct ClDriverParams;
@@ -53,8 +53,8 @@
   public:
     ClDriver(ClDriverParams *p);
     void handshake(GpuDispatcher *_dispatcher);
-    int open(LiveProcess *p, ThreadContext *tc, int mode, int flags);
-    int ioctl(LiveProcess *p, ThreadContext *tc, unsigned req);
+    int open(Process *p, ThreadContext *tc, int mode, int flags);
+    int ioctl(Process *p, ThreadContext *tc, unsigned req);
     const char* codeOffToKernelName(uint64_t code_ptr);
 
   private:
diff --git a/src/gpu-compute/cl_driver.cc b/src/gpu-compute/cl_driver.cc
--- a/src/gpu-compute/cl_driver.cc
+++ b/src/gpu-compute/cl_driver.cc
@@ -91,7 +91,7 @@
 }
 
 int
-ClDriver::open(LiveProcess *p, ThreadContext *tc, int mode, int flags)
+ClDriver::open(Process *p, ThreadContext *tc, int mode, int flags)
 {
     int fd = p->allocFD(-1, filename, 0, 0, false);
     FDEntry *fde = p->getFDEntry(fd);
@@ -101,7 +101,7 @@
 }
 
 int
-ClDriver::ioctl(LiveProcess *process, ThreadContext *tc, unsigned req)
+ClDriver::ioctl(Process *process, ThreadContext *tc, unsigned req)
 {
     int index = 2;
     Addr buf_addr = process->getSyscallArg(tc, index);
diff --git a/src/kern/freebsd/freebsd.hh b/src/kern/freebsd/freebsd.hh
--- a/src/kern/freebsd/freebsd.hh
+++ b/src/kern/freebsd/freebsd.hh
@@ -39,7 +39,7 @@
 #include "kern/operatingsystem.hh"
 
 class ThreadContext;
-class LiveProcess;
+class Process;
 
 ///
 /// This class encapsulates the types, structures, constants,
diff --git a/src/kern/linux/linux.hh b/src/kern/linux/linux.hh
--- a/src/kern/linux/linux.hh
+++ b/src/kern/linux/linux.hh
@@ -223,8 +223,9 @@
         int64_t ru_nivcsw;              //!< involuntary "
     };
 
-    static int openSpecialFile(std::string path, LiveProcess *process, ThreadContext *tc);
-    static std::string procMeminfo(LiveProcess *process, ThreadContext *tc);
+    static int openSpecialFile(std::string path, Process *process,
+                               ThreadContext *tc);
+    static std::string procMeminfo(Process *process, ThreadContext *tc);
 
     // For futex system call
     static const unsigned TGT_FUTEX_WAIT  = 0;
diff --git a/src/kern/linux/linux.cc b/src/kern/linux/linux.cc
--- a/src/kern/linux/linux.cc
+++ b/src/kern/linux/linux.cc
@@ -38,7 +38,7 @@
 #include "sim/system.hh"
 
 int
-Linux::openSpecialFile(std::string path, LiveProcess *process,
+Linux::openSpecialFile(std::string path, Process *process,
                        ThreadContext *tc)
 {
     DPRINTF(SyscallVerbose, "Opening special file: %s\n", path.c_str());
@@ -59,7 +59,7 @@
 }
 
 std::string
-Linux::procMeminfo(LiveProcess *process, ThreadContext *tc)
+Linux::procMeminfo(Process *process, ThreadContext *tc)
 {
     return csprintf("MemTotal:%12d kB\nMemFree: %12d kB\n",
             process->system->memSize() >> 10,
diff --git a/src/kern/operatingsystem.hh b/src/kern/operatingsystem.hh
--- a/src/kern/operatingsystem.hh
+++ b/src/kern/operatingsystem.hh
@@ -35,7 +35,7 @@
 
 #include <string>
 
-class LiveProcess;
+class Process;
 class ThreadContext;
 
 /// This struct is used to build target-OS-dependent tables that
@@ -114,7 +114,8 @@
         int64_t ru_nivcsw;              //!< involuntary "
     } rusage;
 
-    static int openSpecialFile(std::string path, LiveProcess *process, ThreadContext *tc);
+    static int openSpecialFile(std::string path, Process *process,
+                               ThreadContext *tc);
 
 };  // class OperatingSystem
 
diff --git a/src/kern/operatingsystem.cc b/src/kern/operatingsystem.cc
--- a/src/kern/operatingsystem.cc
+++ b/src/kern/operatingsystem.cc
@@ -34,7 +34,7 @@
 #include "base/misc.hh"
 
 int
-OperatingSystem::openSpecialFile(std::string path, LiveProcess *process,
+OperatingSystem::openSpecialFile(std::string path, Process *process,
                                  ThreadContext *tc)
 {
     warn("Attempting to open special file: %s. Ignoring. Simulation may"
diff --git a/src/kern/tru64/tru64.hh b/src/kern/tru64/tru64.hh
--- a/src/kern/tru64/tru64.hh
+++ b/src/kern/tru64/tru64.hh
@@ -430,7 +430,7 @@
 
     /// Target getdirentries() handler.
     static SyscallReturn
-    getdirentriesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process,
                       ThreadContext *tc)
     {
         using namespace TheISA;
@@ -492,7 +492,7 @@
 
     /// Target sigreturn() handler.
     static SyscallReturn
-    sigreturnFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    sigreturnFunc(SyscallDesc *desc, int callnum, Process *process,
                   ThreadContext *tc)
     {
         using namespace TheISA;
@@ -527,7 +527,7 @@
 
     /// Create a stack region for a thread.
     static SyscallReturn
-    stack_createFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    stack_createFunc(SyscallDesc *desc, int callnum, Process *process,
                      ThreadContext *tc)
     {
         using namespace TheISA;
@@ -575,7 +575,7 @@
     /// schedulers by creating a shared-memory region.  The shared memory
     /// region has several structs, some global, some per-RAD, some per-VP.
     static SyscallReturn
-    nxm_task_initFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process,
                       ThreadContext *tc)
     {
         using namespace std;
@@ -690,8 +690,8 @@
 
     /// Initialize thread context.
     static void
-    init_thread_context(LiveProcess *process, ThreadContext *tc,
-                      Tru64::nxm_thread_attr *attrp, uint64_t uniq_val)
+    init_thread_context(Process *process, ThreadContext *tc,
+                        Tru64::nxm_thread_attr *attrp, uint64_t uniq_val)
     {
         using namespace TheISA;
 
@@ -709,7 +709,7 @@
 
     /// Create thread.
     static SyscallReturn
-    nxm_thread_createFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process,
                           ThreadContext *tc)
     {
         using namespace std;
@@ -825,7 +825,7 @@
 
     /// Thread idle call (like yield()).
     static SyscallReturn
-    nxm_idleFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process,
                  ThreadContext *tc)
     {
         return 0;
@@ -833,7 +833,7 @@
 
     /// Block thread.
     static SyscallReturn
-    nxm_thread_blockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process,
                          ThreadContext *tc)
     {
         using namespace std;
@@ -853,7 +853,7 @@
 
     /// block.
     static SyscallReturn
-    nxm_blockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process,
                   ThreadContext *tc)
     {
         using namespace std;
@@ -877,7 +877,7 @@
 
     /// Unblock thread.
     static SyscallReturn
-    nxm_unblockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process,
                     ThreadContext *tc)
     {
         using namespace std;
@@ -893,7 +893,7 @@
 
     /// Switch thread priority.
     static SyscallReturn
-    swtch_priFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    swtch_priFunc(SyscallDesc *desc, int callnum, Process *process,
                   ThreadContext *tc)
     {
         // Attempts to switch to another runnable thread (if there is
@@ -910,7 +910,7 @@
     /// Activate thread context waiting on a channel.  Just activate one
     /// by default.
     static int
-    activate_waiting_context(Addr uaddr, LiveProcess *process,
+    activate_waiting_context(Addr uaddr, Process *process,
                              bool activate_all = false)
     {
         using namespace std;
@@ -941,7 +941,7 @@
 
     /// M5 hacked-up lock acquire.
     static void
-    m5_lock_mutex(Addr uaddr, LiveProcess *process, ThreadContext *tc)
+    m5_lock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
     {
         using namespace TheISA;
 
@@ -962,7 +962,7 @@
 
     /// M5 unlock call.
     static void
-    m5_unlock_mutex(Addr uaddr, LiveProcess *process, ThreadContext *tc)
+    m5_unlock_mutex(Addr uaddr, Process *process, ThreadContext *tc)
     {
         TypedBufferArg<uint64_t> lockp(uaddr);
 
@@ -981,7 +981,7 @@
 
     /// Lock acquire syscall handler.
     static SyscallReturn
-    m5_mutex_lockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process,
                       ThreadContext *tc)
     {
         int index = 0;
@@ -997,7 +997,7 @@
 
     /// Try lock (non-blocking).
     static SyscallReturn
-    m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process,
                          ThreadContext *tc)
     {
         using namespace TheISA;
@@ -1020,7 +1020,7 @@
 
     /// Unlock syscall handler.
     static SyscallReturn
-    m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process,
                         ThreadContext *tc)
     {
         int index = 0;
@@ -1033,7 +1033,7 @@
 
     /// Signal ocndition.
     static SyscallReturn
-    m5_cond_signalFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process,
                        ThreadContext *tc)
     {
         int index = 0;
@@ -1047,7 +1047,7 @@
 
     /// Wake up all processes waiting on the condition variable.
     static SyscallReturn
-    m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process,
                           ThreadContext *tc)
     {
         int index = 0;
@@ -1060,7 +1060,7 @@
 
     /// Wait on a condition.
     static SyscallReturn
-    m5_cond_waitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process,
                      ThreadContext *tc)
     {
         using namespace TheISA;
@@ -1085,7 +1085,7 @@
 
     /// Thread exit.
     static SyscallReturn
-    m5_thread_exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process,
                        ThreadContext *tc)
     {
         assert(tc->status() == ThreadContext::Active);
@@ -1096,7 +1096,7 @@
 
     /// Indirect syscall invocation (call #0).
     static SyscallReturn
-    indirectSyscallFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+    indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process,
                         ThreadContext *tc)
     {
         int index = 0;
diff --git a/src/sim/Process.py b/src/sim/Process.py
--- a/src/sim/Process.py
+++ b/src/sim/Process.py
@@ -32,7 +32,6 @@
 
 class Process(SimObject):
     type = 'Process'
-    abstract = True
     cxx_header = "sim/process.hh"
     input = Param.String('cin', "filename for stdin")
     output = Param.String('cout', 'filename for stdout')
@@ -50,19 +49,6 @@
     pid = Param.Int(100, 'process id')
     ppid = Param.Int(99, 'parent process id')
 
-    @classmethod
-    def export_methods(cls, code):
-        code('bool map(Addr vaddr, Addr paddr, int size, bool cacheable=true);')
-
-class EmulatedDriver(SimObject):
-    type = 'EmulatedDriver'
-    cxx_header = "sim/emul_driver.hh"
-    abstract = True
-    filename = Param.String("device file name (under /dev)")
-
-class LiveProcess(Process):
-    type = 'LiveProcess'
-    cxx_header = "sim/process.hh"
     executable = Param.String('', "executable (overrides cmd[0] if set)")
     cmd = VectorParam.String("command line (executable plus arguments)")
     env = VectorParam.String([], "environment settings")
@@ -70,3 +56,12 @@
     simpoint = Param.UInt64(0, 'simulation point at which to start simulation')
     drivers = VectorParam.EmulatedDriver([], 'Available emulated drivers')
 
+    @classmethod
+    def export_methods(cls, code):
+        code('bool map(Addr vaddr, Addr paddr, int sz, bool cacheable=true);')
+
+class EmulatedDriver(SimObject):
+    type = 'EmulatedDriver'
+    cxx_header = "sim/emul_driver.hh"
+    abstract = True
+    filename = Param.String("device file name (under /dev)")
diff --git a/src/sim/emul_driver.hh b/src/sim/emul_driver.hh
--- a/src/sim/emul_driver.hh
+++ b/src/sim/emul_driver.hh
@@ -36,7 +36,7 @@
 #include "params/EmulatedDriver.hh"
 #include "sim/sim_object.hh"
 
-class LiveProcess;
+class Process;
 class ThreadContext;
 
 /**
@@ -74,7 +74,7 @@
      * to openFunc() (q.v.).
      * @return A newly allocated target fd, or -1 on error.
      */
-    virtual int open(LiveProcess *p, ThreadContext *tc,
+    virtual int open(Process *p, ThreadContext *tc,
                      int mode, int flags) = 0;
 
     /**
@@ -84,7 +84,7 @@
      * @return The return code for the ioctl, or the negation of the errno
      * (see the SyscallReturn class).
      */
-    virtual int ioctl(LiveProcess *p, ThreadContext *tc, unsigned req) = 0;
+    virtual int ioctl(Process *p, ThreadContext *tc, unsigned req) = 0;
 
     /**
      * Virtual method, invoked when the user program calls mmap() on
@@ -93,7 +93,7 @@
      * @return The return ptr for the mmap, or the negation of the errno
      * (see the SyscallReturn class).
      */
-    virtual Addr mmap(LiveProcess *p, ThreadContext *tc, Addr start,
+    virtual Addr mmap(Process *p, ThreadContext *tc, Addr start,
                       uint64_t length, int prot, int tgtFlags, int tgtFd,
                       int offset) { return -EBADF; }
 };
diff --git a/src/sim/process.hh b/src/sim/process.hh
--- a/src/sim/process.hh
+++ b/src/sim/process.hh
@@ -46,10 +46,10 @@
 #include "sim/fd_entry.hh"
 #include "sim/sim_object.hh"
 
-struct LiveProcessParams;
 struct ProcessParams;
 
 class EmulatedDriver;
+class ObjectFile;
 class PageTableBase;
 class SyscallDesc;
 class SyscallReturn;
@@ -170,9 +170,6 @@
     // Find a free context to use
     ThreadContext *findFreeContext();
 
-    // provide program name for debug messages
-    virtual const char *progName() const { return "<unknown>"; }
-
     // generate new target fd for sim_fd
     int allocFD(int sim_fd, const std::string& filename, int flags, int mode,
                 bool pipe);
@@ -202,7 +199,6 @@
     // set the source of this read pipe for a checkpoint resume
     void setReadPipeSource(int read_pipe_fd, int source_fd);
 
-    virtual void syscall(int64_t callnum, ThreadContext *tc) = 0;
 
     void allocateMem(Addr vaddr, int64_t size, bool clobber = false);
 
@@ -228,6 +224,15 @@
     void serialize(CheckpointOut &cp) const override;
     void unserialize(CheckpointIn &cp) override;
 
+  protected:
+    ObjectFile *objFile;
+    std::vector<std::string> argv;
+    std::vector<std::string> envp;
+    std::string cwd;
+    std::string executable;
+
+    Process(ProcessParams *params, ObjectFile *obj_file);
+
   public:
     // Id of the owner of the process
     uint64_t _uid;
@@ -239,28 +244,9 @@
     uint64_t _pid;
     uint64_t _ppid;
 
-};
-
-//
-// "Live" process with system calls redirected to host system
-//
-class ObjectFile;
-class LiveProcess : public Process
-{
-  protected:
-    ObjectFile *objFile;
-    std::vector<std::string> argv;
-    std::vector<std::string> envp;
-    std::string cwd;
-    std::string executable;
-
-    LiveProcess(LiveProcessParams *params, ObjectFile *objFile);
-
     // Emulated drivers available to this process
     std::vector<EmulatedDriver *> drivers;
 
-  public:
-
     enum AuxiliaryVectorType {
         M5_AT_NULL = 0,
         M5_AT_IGNORE = 1,
@@ -299,7 +285,7 @@
     inline uint64_t ppid() { return _ppid; }
 
     // provide program name for debug messages
-    virtual const char *progName() const { return executable.c_str(); }
+    const char *progName() const { return executable.c_str(); }
 
     std::string
     fullPath(const std::string &filename)
@@ -317,7 +303,7 @@
 
     std::string getcwd() const { return cwd; }
 
-    virtual void syscall(int64_t callnum, ThreadContext *tc);
+    void syscall(int64_t callnum, ThreadContext *tc);
 
     virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i) = 0;
     virtual TheISA::IntReg getSyscallArg(ThreadContext *tc, int &i, int width);
@@ -345,12 +331,6 @@
 
     Addr getBias();
     Addr getStartPC();
-
-    // this function is used to create the LiveProcess object, since
-    // we can't tell which subclass of LiveProcess to use until we
-    // open and look at the object file.
-    static LiveProcess *create(LiveProcessParams *params);
 };
 
-
 #endif // __PROCESS_HH__
diff --git a/src/sim/process.cc b/src/sim/process.cc
--- a/src/sim/process.cc
+++ b/src/sim/process.cc
@@ -61,7 +61,6 @@
 #include "cpu/thread_context.hh"
 #include "mem/page_table.hh"
 #include "mem/se_translating_port_proxy.hh"
-#include "params/LiveProcess.hh"
 #include "params/Process.hh"
 #include "sim/emul_driver.hh"
 #include "sim/syscall_desc.hh"
@@ -131,7 +130,7 @@
     return openFile(filename, O_WRONLY | O_CREAT | O_TRUNC, 0664);
 }
 
-Process::Process(ProcessParams * params)
+Process::Process(ProcessParams * params, ObjectFile * obj_file)
     : SimObject(params), system(params->system),
       brk_point(0), stack_base(0), stack_size(0), stack_min(0),
       max_stack_size(params->max_stack_size),
@@ -152,9 +151,13 @@
             {"stdout", STDOUT_FILENO},
             {"cerr",   STDERR_FILENO},
             {"stderr", STDERR_FILENO}},
+      objFile(obj_file),
+      argv(params->cmd), envp(params->env), cwd(params->cwd),
+      executable(params->executable),
       _uid(params->uid), _euid(params->euid),
       _gid(params->gid), _egid(params->egid),
-      _pid(params->pid), _ppid(params->ppid)
+      _pid(params->pid), _ppid(params->ppid),
+      drivers(params->drivers)
 {
     int sim_fd;
     std::map<string,int>::iterator it;
@@ -192,6 +195,19 @@
     mmap_end = 0;
     nxm_start = nxm_end = 0;
     // other parameters will be initialized when the program is loaded
+
+    // load up symbols, if any... these may be used for debugging or
+    // profiling.
+    if (!debugSymbolTable) {
+        debugSymbolTable = new SymbolTable();
+        if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
+            !objFile->loadLocalSymbols(debugSymbolTable) ||
+            !objFile->loadWeakSymbols(debugSymbolTable)) {
+            // didn't load any symbols
+            delete debugSymbolTable;
+            debugSymbolTable = NULL;
+        }
+    }
 }
 
 
@@ -464,36 +480,8 @@
 }
 
 
-////////////////////////////////////////////////////////////////////////
-//
-// LiveProcess member definitions
-//
-////////////////////////////////////////////////////////////////////////
-
-
-LiveProcess::LiveProcess(LiveProcessParams *params, ObjectFile *_objFile)
-    : Process(params), objFile(_objFile),
-      argv(params->cmd), envp(params->env), cwd(params->cwd),
-      executable(params->executable),
-      drivers(params->drivers)
-{
-
-    // load up symbols, if any... these may be used for debugging or
-    // profiling.
-    if (!debugSymbolTable) {
-        debugSymbolTable = new SymbolTable();
-        if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
-            !objFile->loadLocalSymbols(debugSymbolTable) ||
-            !objFile->loadWeakSymbols(debugSymbolTable)) {
-            // didn't load any symbols
-            delete debugSymbolTable;
-            debugSymbolTable = NULL;
-        }
-    }
-}
-
 void
-LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
+Process::syscall(int64_t callnum, ThreadContext *tc)
 {
     num_syscalls++;
 
@@ -505,14 +493,14 @@
 }
 
 IntReg
-LiveProcess::getSyscallArg(ThreadContext *tc, int &i, int width)
+Process::getSyscallArg(ThreadContext *tc, int &i, int width)
 {
     return getSyscallArg(tc, i);
 }
 
 
 EmulatedDriver *
-LiveProcess::findDriver(std::string filename)
+Process::findDriver(std::string filename)
 {
     for (EmulatedDriver *d : drivers) {
         if (d->match(filename))
@@ -523,7 +511,7 @@
 }
 
 void
-LiveProcess::updateBias()
+Process::updateBias()
 {
     ObjectFile *interp = objFile->getInterpreter();
 
@@ -548,14 +536,14 @@
 
 
 ObjectFile *
-LiveProcess::getInterpreter()
+Process::getInterpreter()
 {
     return objFile->getInterpreter();
 }
 
 
 Addr
-LiveProcess::getBias()
+Process::getBias()
 {
     ObjectFile *interp = getInterpreter();
 
@@ -564,7 +552,7 @@
 
 
 Addr
-LiveProcess::getStartPC()
+Process::getStartPC()
 {
     ObjectFile *interp = getInterpreter();
 
@@ -572,78 +560,78 @@
 }
 
 
-LiveProcess *
-LiveProcess::create(LiveProcessParams * params)
+Process *
+ProcessParams::create()
 {
-    LiveProcess *process = NULL;
+    Process *process = NULL;
 
     // If not specified, set the executable parameter equal to the
     // simulated system's zeroth command line parameter
-    if (params->executable == "") {
-        params->executable = params->cmd[0];
+    if (executable == "") {
+        executable = cmd[0];
     }
 
-    ObjectFile *objFile = createObjectFile(params->executable);
-    if (objFile == NULL) {
-        fatal("Can't load object file %s", params->executable);
+    ObjectFile *obj_file = createObjectFile(executable);
+    if (obj_file == NULL) {
+        fatal("Can't load object file %s", executable);
     }
 
 #if THE_ISA == ALPHA_ISA
-    if (objFile->getArch() != ObjectFile::Alpha)
+    if (obj_file->getArch() != ObjectFile::Alpha)
         fatal("Object file architecture does not match compiled ISA (Alpha).");
 
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::Tru64:
-        process = new AlphaTru64Process(params, objFile);
+        process = new AlphaTru64Process(this, obj_file);
         break;
 
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
-        process = new AlphaLinuxProcess(params, objFile);
+        process = new AlphaLinuxProcess(this, obj_file);
         break;
 
       default:
         fatal("Unknown/unsupported operating system.");
     }
 #elif THE_ISA == SPARC_ISA
-    if (objFile->getArch() != ObjectFile::SPARC64 &&
-        objFile->getArch() != ObjectFile::SPARC32)
+    if (obj_file->getArch() != ObjectFile::SPARC64 &&
+        obj_file->getArch() != ObjectFile::SPARC32)
         fatal("Object file architecture does not match compiled ISA (SPARC).");
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
-        if (objFile->getArch() == ObjectFile::SPARC64) {
-            process = new Sparc64LinuxProcess(params, objFile);
+        if (obj_file->getArch() == ObjectFile::SPARC64) {
+            process = new Sparc64LinuxProcess(this, obj_file);
         } else {
-            process = new Sparc32LinuxProcess(params, objFile);
+            process = new Sparc32LinuxProcess(this, obj_file);
         }
         break;
 
 
       case ObjectFile::Solaris:
-        process = new SparcSolarisProcess(params, objFile);
+        process = new SparcSolarisProcess(this, obj_file);
         break;
 
       default:
         fatal("Unknown/unsupported operating system.");
     }
 #elif THE_ISA == X86_ISA
-    if (objFile->getArch() != ObjectFile::X86_64 &&
-        objFile->getArch() != ObjectFile::I386)
+    if (obj_file->getArch() != ObjectFile::X86_64 &&
+        obj_file->getArch() != ObjectFile::I386)
         fatal("Object file architecture does not match compiled ISA (x86).");
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
-        if (objFile->getArch() == ObjectFile::X86_64) {
-            process = new X86_64LinuxProcess(params, objFile);
+        if (obj_file->getArch() == ObjectFile::X86_64) {
+            process = new X86_64LinuxProcess(this, obj_file);
         } else {
-            process = new I386LinuxProcess(params, objFile);
+            process = new I386LinuxProcess(this, obj_file);
         }
         break;
 
@@ -651,44 +639,44 @@
         fatal("Unknown/unsupported operating system.");
     }
 #elif THE_ISA == MIPS_ISA
-    if (objFile->getArch() != ObjectFile::Mips)
+    if (obj_file->getArch() != ObjectFile::Mips)
         fatal("Object file architecture does not match compiled ISA (MIPS).");
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
-        process = new MipsLinuxProcess(params, objFile);
+        process = new MipsLinuxProcess(this, obj_file);
         break;
 
       default:
         fatal("Unknown/unsupported operating system.");
     }
 #elif THE_ISA == ARM_ISA
-    ObjectFile::Arch arch = objFile->getArch();
+    ObjectFile::Arch arch = obj_file->getArch();
     if (arch != ObjectFile::Arm && arch != ObjectFile::Thumb &&
         arch != ObjectFile::Arm64)
         fatal("Object file architecture does not match compiled ISA (ARM).");
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
         if (arch == ObjectFile::Arm64) {
-            process = new ArmLinuxProcess64(params, objFile,
-                                            objFile->getArch());
+            process = new ArmLinuxProcess64(this, obj_file,
+                                            obj_file->getArch());
         } else {
-            process = new ArmLinuxProcess32(params, objFile,
-                                            objFile->getArch());
+            process = new ArmLinuxProcess32(this, obj_file,
+                                            obj_file->getArch());
         }
         break;
       case ObjectFile::FreeBSD:
         if (arch == ObjectFile::Arm64) {
-            process = new ArmFreebsdProcess64(params, objFile,
-                                              objFile->getArch());
+            process = new ArmFreebsdProcess64(this, obj_file,
+                                              obj_file->getArch());
         } else {
-            process = new ArmFreebsdProcess32(params, objFile,
-                                              objFile->getArch());
+            process = new ArmFreebsdProcess32(this, obj_file,
+                                              obj_file->getArch());
         }
         break;
       case ObjectFile::LinuxArmOABI:
@@ -698,14 +686,14 @@
         fatal("Unknown/unsupported operating system.");
     }
 #elif THE_ISA == POWER_ISA
-    if (objFile->getArch() != ObjectFile::Power)
+    if (obj_file->getArch() != ObjectFile::Power)
         fatal("Object file architecture does not match compiled ISA (Power).");
-    switch (objFile->getOpSys()) {
+    switch (obj_file->getOpSys()) {
       case ObjectFile::UnknownOpSys:
         warn("Unknown operating system; assuming Linux.");
         // fall through
       case ObjectFile::Linux:
-        process = new PowerLinuxProcess(params, objFile);
+        process = new PowerLinuxProcess(this, obj_file);
         break;
 
       default:
@@ -719,9 +707,3 @@
         fatal("Unknown error creating process object.");
     return process;
 }
-
-LiveProcess *
-LiveProcessParams::create()
-{
-    return LiveProcess::create(this);
-}
diff --git a/src/sim/syscall_desc.hh b/src/sim/syscall_desc.hh
--- a/src/sim/syscall_desc.hh
+++ b/src/sim/syscall_desc.hh
@@ -19,7 +19,7 @@
 
 #include <string>
 
-class LiveProcess;
+class Process;
 class SyscallReturn;
 class ThreadContext;
 
@@ -33,7 +33,7 @@
   public:
     /** Typedef the function pointer here to clean up code below */
     typedef SyscallReturn (*SyscallExecutor)(SyscallDesc*, int num,
-                                             LiveProcess*, ThreadContext*);
+                                             Process*, ThreadContext*);
 
     SyscallDesc(const char *name, SyscallExecutor sys_exec, int flags = 0)
         : _name(name), executor(sys_exec), _flags(flags), _warned(false)
@@ -62,7 +62,7 @@
      * @param proc Handle for the owning Process to pass information
      * @param tc Handle for owning ThreadContext to pass information
      */
-    void doSyscall(int callnum, LiveProcess *proc, ThreadContext *tc);
+    void doSyscall(int callnum, Process *proc, ThreadContext *tc);
 
     bool
     warnOnce() const
diff --git a/src/sim/syscall_desc.cc b/src/sim/syscall_desc.cc
--- a/src/sim/syscall_desc.cc
+++ b/src/sim/syscall_desc.cc
@@ -25,7 +25,7 @@
 #include "sim/syscall_return.hh"
 
 void
-SyscallDesc::doSyscall(int callnum, LiveProcess *process, ThreadContext *tc)
+SyscallDesc::doSyscall(int callnum, Process *process, ThreadContext *tc)
 {
     TheISA::IntReg arg[6] M5_VAR_USED;
 
diff --git a/src/sim/syscall_emul.hh b/src/sim/syscall_emul.hh
--- a/src/sim/syscall_emul.hh
+++ b/src/sim/syscall_emul.hh
@@ -97,176 +97,175 @@
 
 /// Handler for unimplemented syscalls that we haven't thought about.
 SyscallReturn unimplementedFunc(SyscallDesc *desc, int num,
-                                LiveProcess *p, ThreadContext *tc);
+                                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,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target exit() handler: terminate current context.
 SyscallReturn exitFunc(SyscallDesc *desc, int num,
-                       LiveProcess *p, ThreadContext *tc);
+                       Process *p, ThreadContext *tc);
 
 /// Target exit_group() handler: terminate simulation. (exit all threads)
 SyscallReturn exitGroupFunc(SyscallDesc *desc, int num,
-                       LiveProcess *p, ThreadContext *tc);
+                       Process *p, ThreadContext *tc);
 
 /// Target getpagesize() handler.
 SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num,
-                              LiveProcess *p, ThreadContext *tc);
+                              Process *p, ThreadContext *tc);
 
 /// Target brk() handler: set brk address.
 SyscallReturn brkFunc(SyscallDesc *desc, int num,
-                      LiveProcess *p, ThreadContext *tc);
+                      Process *p, ThreadContext *tc);
 
 /// Target close() handler.
 SyscallReturn closeFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 /// Target read() handler.
 SyscallReturn readFunc(SyscallDesc *desc, int num,
-                       LiveProcess *p, ThreadContext *tc);
+                       Process *p, ThreadContext *tc);
 
 /// Target write() handler.
 SyscallReturn writeFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 /// Target lseek() handler.
 SyscallReturn lseekFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 /// Target _llseek() handler.
 SyscallReturn _llseekFunc(SyscallDesc *desc, int num,
-                          LiveProcess *p, ThreadContext *tc);
+                          Process *p, ThreadContext *tc);
 
 /// Target munmap() handler.
 SyscallReturn munmapFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target gethostname() handler.
 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
-                              LiveProcess *p, ThreadContext *tc);
+                              Process *p, ThreadContext *tc);
 
 /// Target getcwd() handler.
 SyscallReturn getcwdFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target readlink() handler.
 SyscallReturn readlinkFunc(SyscallDesc *desc, int num,
-                           LiveProcess *p, ThreadContext *tc,
+                           Process *p, ThreadContext *tc,
                            int index = 0);
 SyscallReturn readlinkFunc(SyscallDesc *desc, int num,
-                           LiveProcess *p, ThreadContext *tc);
+                           Process *p, ThreadContext *tc);
 
 /// Target unlink() handler.
 SyscallReturn unlinkHelper(SyscallDesc *desc, int num,
-                           LiveProcess *p, ThreadContext *tc,
+                           Process *p, ThreadContext *tc,
                            int index);
 SyscallReturn unlinkFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target mkdir() handler.
 SyscallReturn mkdirFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 /// Target rename() handler.
 SyscallReturn renameFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 
 /// Target truncate() handler.
 SyscallReturn truncateFunc(SyscallDesc *desc, int num,
-                           LiveProcess *p, ThreadContext *tc);
+                           Process *p, ThreadContext *tc);
 
 
 /// Target ftruncate() handler.
 SyscallReturn ftruncateFunc(SyscallDesc *desc, int num,
-                            LiveProcess *p, ThreadContext *tc);
+                            Process *p, ThreadContext *tc);
 
 
 /// Target truncate64() handler.
 SyscallReturn truncate64Func(SyscallDesc *desc, int num,
-                             LiveProcess *p, ThreadContext *tc);
+                             Process *p, ThreadContext *tc);
 
 /// Target ftruncate64() handler.
 SyscallReturn ftruncate64Func(SyscallDesc *desc, int num,
-                              LiveProcess *p, ThreadContext *tc);
+                              Process *p, ThreadContext *tc);
 
 
 /// Target umask() handler.
 SyscallReturn umaskFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 
 /// Target chown() handler.
 SyscallReturn chownFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 
 /// Target fchown() handler.
 SyscallReturn fchownFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target dup() handler.
 SyscallReturn dupFunc(SyscallDesc *desc, int num,
-                      LiveProcess *process, ThreadContext *tc);
+                      Process *process, ThreadContext *tc);
 
 /// Target fnctl() handler.
 SyscallReturn fcntlFunc(SyscallDesc *desc, int num,
-                        LiveProcess *process, ThreadContext *tc);
+                        Process *process, ThreadContext *tc);
 
 /// Target fcntl64() handler.
 SyscallReturn fcntl64Func(SyscallDesc *desc, int num,
-                          LiveProcess *process, ThreadContext *tc);
+                          Process *process, ThreadContext *tc);
 
 /// Target setuid() handler.
 SyscallReturn setuidFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target getpid() handler.
 SyscallReturn getpidFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target getuid() handler.
 SyscallReturn getuidFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target getgid() handler.
 SyscallReturn getgidFunc(SyscallDesc *desc, int num,
-                         LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 
 /// Target getppid() handler.
 SyscallReturn getppidFunc(SyscallDesc *desc, int num,
-                          LiveProcess *p, ThreadContext *tc);
+                          Process *p, ThreadContext *tc);
 
 /// Target geteuid() handler.
 SyscallReturn geteuidFunc(SyscallDesc *desc, int num,
-                          LiveProcess *p, ThreadContext *tc);
+                          Process *p, ThreadContext *tc);
 
 /// Target getegid() handler.
 SyscallReturn getegidFunc(SyscallDesc *desc, int num,
-                          LiveProcess *p, ThreadContext *tc);
+                          Process *p, ThreadContext *tc);
 
 /// Target clone() handler.
 SyscallReturn cloneFunc(SyscallDesc *desc, int num,
-                        LiveProcess *p, ThreadContext *tc);
+                        Process *p, ThreadContext *tc);
 
 /// Target access() handler
 SyscallReturn accessFunc(SyscallDesc *desc, int num,
-                               LiveProcess *p, ThreadContext *tc);
+                         Process *p, ThreadContext *tc);
 SyscallReturn accessFunc(SyscallDesc *desc, int num,
-                               LiveProcess *p, ThreadContext *tc,
-                               int index);
+                         Process *p, ThreadContext *tc, int index);
 
 /// Futex system call
 ///  Implemented by Daniel Sanchez
 ///  Used by printf's in multi-threaded apps
 template <class OS>
 SyscallReturn
-futexFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+futexFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index_uaddr = 0;
@@ -347,19 +346,19 @@
 /// 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,
-                             LiveProcess *process, ThreadContext *tc);
+                             Process *process, ThreadContext *tc);
 
 /// Target getpidPseudo() handler.
 SyscallReturn getpidPseudoFunc(SyscallDesc *desc, int num,
-                               LiveProcess *p, ThreadContext *tc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getuidPseudo() handler.
 SyscallReturn getuidPseudoFunc(SyscallDesc *desc, int num,
-                               LiveProcess *p, ThreadContext *tc);
+                               Process *p, ThreadContext *tc);
 
 /// Target getgidPseudo() handler.
 SyscallReturn getgidPseudoFunc(SyscallDesc *desc, int num,
-                               LiveProcess *p, ThreadContext *tc);
+                               Process *p, ThreadContext *tc);
 
 
 /// A readable name for 1,000,000, for converting microseconds to seconds.
@@ -512,7 +511,7 @@
 /// not TTYs to provide repeatable results.
 template <class OS>
 SyscallReturn
-ioctlFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -543,7 +542,7 @@
 
 template <class OS>
 static SyscallReturn
-openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+openFunc(SyscallDesc *desc, int callnum, Process *process,
          ThreadContext *tc, int index)
 {
     std::string path;
@@ -619,7 +618,7 @@
 /// Target open() handler.
 template <class OS>
 SyscallReturn
-openFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+openFunc(SyscallDesc *desc, int callnum, Process *process,
          ThreadContext *tc)
 {
     return openFunc<OS>(desc, callnum, process, tc, 0);
@@ -628,8 +627,8 @@
 /// Target openat() handler.
 template <class OS>
 SyscallReturn
-openatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-         ThreadContext *tc)
+openatFunc(SyscallDesc *desc, int callnum, Process *process,
+           ThreadContext *tc)
 {
     int index = 0;
     int dirfd = process->getSyscallArg(tc, index);
@@ -641,7 +640,7 @@
 /// Target unlinkat() handler.
 template <class OS>
 SyscallReturn
-unlinkatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unlinkatFunc(SyscallDesc *desc, int callnum, Process *process,
              ThreadContext *tc)
 {
     int index = 0;
@@ -655,8 +654,8 @@
 /// Target facessat() handler
 template <class OS>
 SyscallReturn
-faccessatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-        ThreadContext *tc)
+faccessatFunc(SyscallDesc *desc, int callnum, Process *process,
+              ThreadContext *tc)
 {
     int index = 0;
     int dirfd = process->getSyscallArg(tc, index);
@@ -668,8 +667,8 @@
 /// Target readlinkat() handler
 template <class OS>
 SyscallReturn
-readlinkatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-        ThreadContext *tc)
+readlinkatFunc(SyscallDesc *desc, int callnum, Process *process,
+               ThreadContext *tc)
 {
     int index = 0;
     int dirfd = process->getSyscallArg(tc, index);
@@ -681,7 +680,7 @@
 /// Target renameat() handler.
 template <class OS>
 SyscallReturn
-renameatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+renameatFunc(SyscallDesc *desc, int callnum, Process *process,
              ThreadContext *tc)
 {
     int index = 0;
@@ -717,8 +716,8 @@
 /// Target sysinfo() handler.
 template <class OS>
 SyscallReturn
-sysinfoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-         ThreadContext *tc)
+sysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
+            ThreadContext *tc)
 {
 
     int index = 0;
@@ -736,7 +735,7 @@
 /// Target chmod() handler.
 template <class OS>
 SyscallReturn
-chmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+chmodFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     std::string path;
@@ -768,7 +767,7 @@
 /// Target fchmod() handler.
 template <class OS>
 SyscallReturn
-fchmodFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+fchmodFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     int index = 0;
@@ -795,7 +794,7 @@
 /// Target mremap() handler.
 template <class OS>
 SyscallReturn
-mremapFunc(SyscallDesc *desc, int callnum, LiveProcess *process, ThreadContext *tc)
+mremapFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
 {
     int index = 0;
     Addr start = process->getSyscallArg(tc, index);
@@ -861,7 +860,7 @@
 /// Target stat() handler.
 template <class OS>
 SyscallReturn
-statFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+statFunc(SyscallDesc *desc, int callnum, Process *process,
          ThreadContext *tc)
 {
     std::string path;
@@ -891,7 +890,7 @@
 /// Target stat64() handler.
 template <class OS>
 SyscallReturn
-stat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
+stat64Func(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     std::string path;
@@ -925,7 +924,7 @@
 /// Target fstatat64() handler.
 template <class OS>
 SyscallReturn
-fstatat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
+fstatat64Func(SyscallDesc *desc, int callnum, Process *process,
               ThreadContext *tc)
 {
     int index = 0;
@@ -962,7 +961,7 @@
 /// Target fstat64() handler.
 template <class OS>
 SyscallReturn
-fstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
+fstat64Func(SyscallDesc *desc, int callnum, Process *process,
             ThreadContext *tc)
 {
     int index = 0;
@@ -993,7 +992,7 @@
 /// Target lstat() handler.
 template <class OS>
 SyscallReturn
-lstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+lstatFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     std::string path;
@@ -1022,7 +1021,7 @@
 /// Target lstat64() handler.
 template <class OS>
 SyscallReturn
-lstat64Func(SyscallDesc *desc, int callnum, LiveProcess *process,
+lstat64Func(SyscallDesc *desc, int callnum, Process *process,
             ThreadContext *tc)
 {
     std::string path;
@@ -1056,7 +1055,7 @@
 /// Target fstat() handler.
 template <class OS>
 SyscallReturn
-fstatFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+fstatFunc(SyscallDesc *desc, int callnum, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -1084,7 +1083,7 @@
 /// Target statfs() handler.
 template <class OS>
 SyscallReturn
-statfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+statfsFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     std::string path;
@@ -1114,7 +1113,7 @@
 /// Target fstatfs() handler.
 template <class OS>
 SyscallReturn
-fstatfsFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+fstatfsFunc(SyscallDesc *desc, int callnum, Process *process,
             ThreadContext *tc)
 {
     int index = 0;
@@ -1140,7 +1139,7 @@
 /// Target writev() handler.
 template <class OS>
 SyscallReturn
-writevFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+writevFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     int index = 0;
@@ -1179,7 +1178,7 @@
 /// Real mmap handler.
 template <class OS>
 SyscallReturn
-mmapImpl(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc,
+mmapImpl(SyscallDesc *desc, int num, Process *p, ThreadContext *tc,
          bool is_mmap2)
 {
     int index = 0;
@@ -1352,7 +1351,7 @@
 
 template <class OS>
 SyscallReturn
-pwrite64Func(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+pwrite64Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -1375,7 +1374,7 @@
 /// Target mmap() handler.
 template <class OS>
 SyscallReturn
-mmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+mmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     return mmapImpl<OS>(desc, num, p, tc, false);
 }
@@ -1383,7 +1382,7 @@
 /// Target mmap2() handler.
 template <class OS>
 SyscallReturn
-mmap2Func(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+mmap2Func(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     return mmapImpl<OS>(desc, num, p, tc, true);
 }
@@ -1391,8 +1390,8 @@
 /// Target getrlimit() handler.
 template <class OS>
 SyscallReturn
-getrlimitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-        ThreadContext *tc)
+getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
+              ThreadContext *tc)
 {
     int index = 0;
     unsigned resource = process->getSyscallArg(tc, index);
@@ -1426,7 +1425,7 @@
 /// Target clock_gettime() function.
 template <class OS>
 SyscallReturn
-clock_gettimeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+clock_gettimeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 1;
     //int clk_id = p->getSyscallArg(tc, index);
@@ -1445,7 +1444,7 @@
 /// Target clock_getres() function.
 template <class OS>
 SyscallReturn
-clock_getresFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+clock_getresFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 1;
     TypedBufferArg<typename OS::timespec> tp(p->getSyscallArg(tc, index));
@@ -1462,8 +1461,8 @@
 /// Target gettimeofday() handler.
 template <class OS>
 SyscallReturn
-gettimeofdayFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-        ThreadContext *tc)
+gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
+                 ThreadContext *tc)
 {
     int index = 0;
     TypedBufferArg<typename OS::timeval> tp(process->getSyscallArg(tc, index));
@@ -1482,7 +1481,7 @@
 /// Target utimes() handler.
 template <class OS>
 SyscallReturn
-utimesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+utimesFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     std::string path;
@@ -1517,7 +1516,7 @@
 /// Target getrusage() function.
 template <class OS>
 SyscallReturn
-getrusageFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
               ThreadContext *tc)
 {
     int index = 0;
@@ -1569,8 +1568,8 @@
 /// Target times() function.
 template <class OS>
 SyscallReturn
-timesFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+timesFunc(SyscallDesc *desc, int callnum, Process *process,
+          ThreadContext *tc)
 {
     int index = 0;
     TypedBufferArg<typename OS::tms> bufp(process->getSyscallArg(tc, index));
@@ -1595,8 +1594,7 @@
 /// Target time() function.
 template <class OS>
 SyscallReturn
-timeFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+timeFunc(SyscallDesc *desc, int callnum, Process *process, ThreadContext *tc)
 {
     typename OS::time_t sec, usec;
     getElapsedTimeMicro(sec, usec);
diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc
--- a/src/sim/syscall_emul.cc
+++ b/src/sim/syscall_emul.cc
@@ -53,7 +53,7 @@
 using namespace TheISA;
 
 SyscallReturn
-unimplementedFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
                   ThreadContext *tc)
 {
     fatal("syscall %s (#%d) unimplemented.", desc->name(), callnum);
@@ -63,7 +63,7 @@
 
 
 SyscallReturn
-ignoreFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     const char *extra_text = "";
@@ -83,7 +83,7 @@
 
 
 SyscallReturn
-exitFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+exitFunc(SyscallDesc *desc, int callnum, Process *process,
          ThreadContext *tc)
 {
     if (process->system->numRunningContexts() == 1) {
@@ -101,7 +101,7 @@
 
 
 SyscallReturn
-exitGroupFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+exitGroupFunc(SyscallDesc *desc, int callnum, Process *process,
               ThreadContext *tc)
 {
     // halt all threads belonging to this process
@@ -121,14 +121,14 @@
 
 
 SyscallReturn
-getpagesizeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     return (int)PageBytes;
 }
 
 
 SyscallReturn
-brkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+brkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     // change brk addr to first arg
     int index = 0;
@@ -174,7 +174,7 @@
 
 
 SyscallReturn
-closeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+closeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -193,7 +193,7 @@
 
 
 SyscallReturn
-readFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+readFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -214,7 +214,7 @@
 }
 
 SyscallReturn
-writeFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+writeFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -237,7 +237,7 @@
 
 
 SyscallReturn
-lseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+lseekFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -255,7 +255,7 @@
 
 
 SyscallReturn
-_llseekFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+_llseekFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = p->getSyscallArg(tc, index);
@@ -284,7 +284,7 @@
 
 
 SyscallReturn
-munmapFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+munmapFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     // With mmap more fully implemented, it might be worthwhile to bite
     // the bullet and implement munmap. Should allow us to reuse simulated
@@ -296,7 +296,7 @@
 const char *hostname = "m5.eecs.umich.edu";
 
 SyscallReturn
-gethostnameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+gethostnameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int index = 0;
     Addr bufPtr = p->getSyscallArg(tc, index);
@@ -311,7 +311,7 @@
 }
 
 SyscallReturn
-getcwdFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+getcwdFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     int result = 0;
     int index = 0;
@@ -343,15 +343,15 @@
 
 /// Target open() handler.
 SyscallReturn
-readlinkFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-         ThreadContext *tc)
+readlinkFunc(SyscallDesc *desc, int callnum, Process *process,
+             ThreadContext *tc)
 {
     return readlinkFunc(desc, callnum, process, tc, 0);
 }
 
 SyscallReturn
-readlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc,
-        int index)
+readlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc,
+             int index)
 {
     string path;
 
@@ -372,7 +372,7 @@
     } else {
         // Emulate readlink() called on '/proc/self/exe' should return the
         // absolute path of the binary running in the simulated system (the
-        // LiveProcess' executable). It is possible that using this path in
+        // Process' executable). It is possible that using this path in
         // the simulated system will result in unexpected behavior if:
         //  1) One binary runs another (e.g., -c time -o "my_binary"), and
         //     called binary calls readlink().
@@ -410,14 +410,14 @@
 }
 
 SyscallReturn
-unlinkFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+unlinkFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     return unlinkHelper(desc, num, p, tc, 0);
 }
 
 SyscallReturn
-unlinkHelper(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc,
-           int index)
+unlinkHelper(SyscallDesc *desc, int num, Process *p, ThreadContext *tc,
+             int index)
 {
     string path;
 
@@ -433,7 +433,7 @@
 
 
 SyscallReturn
-mkdirFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+mkdirFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
@@ -451,7 +451,7 @@
 }
 
 SyscallReturn
-renameFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+renameFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string old_name;
 
@@ -473,7 +473,7 @@
 }
 
 SyscallReturn
-truncateFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+truncateFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
@@ -492,7 +492,7 @@
 
 SyscallReturn
 ftruncateFunc(SyscallDesc *desc, int num,
-              LiveProcess *process, ThreadContext *tc)
+              Process *process, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = process->getSyscallArg(tc, index);
@@ -508,7 +508,7 @@
 
 SyscallReturn
 truncate64Func(SyscallDesc *desc, int num,
-                LiveProcess *process, ThreadContext *tc)
+               Process *process, ThreadContext *tc)
 {
     int index = 0;
     string path;
@@ -531,7 +531,7 @@
 
 SyscallReturn
 ftruncate64Func(SyscallDesc *desc, int num,
-                LiveProcess *process, ThreadContext *tc)
+                Process *process, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = process->getSyscallArg(tc, index);
@@ -550,7 +550,7 @@
 }
 
 SyscallReturn
-umaskFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
+umaskFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 {
     // Letting the simulated program change the simulator's umask seems like
     // a bad idea.  Compromise by just returning the current umask but not
@@ -561,7 +561,7 @@
 }
 
 SyscallReturn
-chownFunc(SyscallDesc *desc, int num, LiveProcess *p, ThreadContext *tc)
+chownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
 {
     string path;
 
@@ -583,7 +583,7 @@
 }
 
 SyscallReturn
-fchownFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
+fchownFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = process->getSyscallArg(tc, index);
@@ -604,7 +604,7 @@
 
 
 SyscallReturn
-dupFunc(SyscallDesc *desc, int num, LiveProcess *process, ThreadContext *tc)
+dupFunc(SyscallDesc *desc, int num, Process *process, ThreadContext *tc)
 {
     int index = 0;
     int tgt_fd = process->getSyscallArg(tc, index);
@@ -622,7 +622,7 @@
 
 
 SyscallReturn
-fcntlFunc(SyscallDesc *desc, int num, LiveProcess *process,
+fcntlFunc(SyscallDesc *desc, int num, Process *process,
           ThreadContext *tc)
 {
     int index = 0;
@@ -666,7 +666,7 @@
 }
 
 SyscallReturn
-fcntl64Func(SyscallDesc *desc, int num, LiveProcess *process,
+fcntl64Func(SyscallDesc *desc, int num, Process *process,
             ThreadContext *tc)
 {
     int index = 0;
@@ -698,8 +698,8 @@
 }
 
 SyscallReturn
-pipePseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-         ThreadContext *tc)
+pipePseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+               ThreadContext *tc)
 {
     int fds[2], sim_fds[2];
     int pipe_retval = pipe(fds);
@@ -721,8 +721,8 @@
 
 
 SyscallReturn
-getpidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+getpidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+                 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
@@ -734,8 +734,8 @@
 
 
 SyscallReturn
-getuidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+getuidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+                 ThreadContext *tc)
 {
     // Make up a UID and EUID... it shouldn't matter, and we want the
     // simulation to be deterministic.
@@ -747,8 +747,8 @@
 
 
 SyscallReturn
-getgidPseudoFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+getgidPseudoFunc(SyscallDesc *desc, int callnum, Process *process,
+                 ThreadContext *tc)
 {
     // Get current group ID.  EGID goes in r20.
     tc->setIntReg(SyscallPseudoReturnReg, process->egid()); //EGID
@@ -757,7 +757,7 @@
 
 
 SyscallReturn
-setuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+setuidFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     // can't fathom why a benchmark would call this.
@@ -767,7 +767,7 @@
 }
 
 SyscallReturn
-getpidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+getpidFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     // Make up a PID.  There's no interprocess communication in
@@ -779,44 +779,44 @@
 }
 
 SyscallReturn
-getppidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+getppidFunc(SyscallDesc *desc, int callnum, Process *process,
+            ThreadContext *tc)
 {
     return process->ppid();
 }
 
 SyscallReturn
-getuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+getuidFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     return process->uid();              // UID
 }
 
 SyscallReturn
-geteuidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+geteuidFunc(SyscallDesc *desc, int callnum, Process *process,
+            ThreadContext *tc)
 {
     return process->euid();             // UID
 }
 
 SyscallReturn
-getgidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
+getgidFunc(SyscallDesc *desc, int callnum, Process *process,
            ThreadContext *tc)
 {
     return process->gid();
 }
 
 SyscallReturn
-getegidFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+getegidFunc(SyscallDesc *desc, int callnum, Process *process,
+            ThreadContext *tc)
 {
     return process->egid();
 }
 
 
 SyscallReturn
-cloneFunc(SyscallDesc *desc, int callnum, LiveProcess *process,
-           ThreadContext *tc)
+cloneFunc(SyscallDesc *desc, int callnum, Process *process,
+          ThreadContext *tc)
 {
     int index = 0;
     IntReg flags = process->getSyscallArg(tc, index);
@@ -897,8 +897,8 @@
 }
 
 SyscallReturn
-accessFunc(SyscallDesc *desc, int callnum, LiveProcess *p, ThreadContext *tc,
-        int index)
+accessFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc,
+           int index)
 {
     string path;
     if (!tc->getMemProxy().tryReadString(path, p->getSyscallArg(tc, index)))
@@ -914,7 +914,7 @@
 }
 
 SyscallReturn
-accessFunc(SyscallDesc *desc, int callnum, LiveProcess *p, ThreadContext *tc)
+accessFunc(SyscallDesc *desc, int callnum, Process *p, ThreadContext *tc)
 {
     return accessFunc(desc, callnum, p, tc, 0);
 }