sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge zizzer:/z/m5/Bitkeeper/m5

Browse source 
into zizzer.eecs.umich.edu:/.automount/zazzer/z/rdreslin/m5bk/timing_L1

--HG--
extra : convert_revision : a5ee8e5187503203058da35ca44918f1ff7ae1eb
This commit is contained in:
Ron Dreslinski 2005-03-10 11:56:07 -05:00
commit e51850f1d2
15 changed files with 233 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
arch/alpha/alpha_linux_process.cc
View file

@ -232,7 +232,7 @@ class Linux {
static const char *hostname;
/// Target uname() handler.
static int
static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -245,13 +245,13 @@ class Linux {
strcpy(name->machine, "alpha");
name.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
/// Target osf_getsysyinfo() handler. Even though this call is
/// borrowed from Tru64, the subcases that get used appear to be
/// different in practice from those used by Tru64 processes.
static int
static SyscallReturn
osf_getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -265,7 +265,7 @@ class Linux {
// I don't think this exactly matches the HW FPCR
*fpcr = 0;
fpcr.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
default:
@ -274,11 +274,11 @@ class Linux {
break;
}
return 1;
return SyscallReturn(1);
}
/// Target osf_setsysinfo() handler.
static int
static SyscallReturn
osf_setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -293,7 +293,7 @@ class Linux {
fpcr.copyIn(xc->mem);
DPRINTFR(SyscallVerbose, "osf_setsysinfo(SSI_IEEE_FP_CONTROL): "
" setting FPCR to 0x%x\n", *(uint64_t*)fpcr);
return 0;
return SyscallReturn(0);
}
default:
@ -302,18 +302,18 @@ class Linux {
break;
}
return 1;
return SyscallReturn(1);
}
/// Target fnctl() handler.
static int
static SyscallReturn
fcntlFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
int fd = xc->getSyscallArg(0);
if (fd < 0 || process->sim_fd(fd) < 0)
return -EBADF;
return SyscallReturn(-EBADF);
int cmd = xc->getSyscallArg(1);
switch (cmd) {
@ -321,18 +321,18 @@ class Linux {
// if we really wanted to support this, we'd need to do it
// in the target fd space.
warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
return -EMFILE;
return SyscallReturn(-EMFILE);
case 1: // F_GETFD (get close-on-exec flag)
case 2: // F_SETFD (set close-on-exec flag)
return 0;
return SyscallReturn(0);
case 3: // F_GETFL (get file flags)
case 4: // F_SETFL (set file flags)
// not sure if this is totally valid, but we'll pass it through
// to the underlying OS
warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
return fcntl(process->sim_fd(fd), cmd);
return SyscallReturn(fcntl(process->sim_fd(fd), cmd));
// return 0;
case 7: // F_GETLK (get lock)
@ -340,11 +340,11 @@ class Linux {
case 9: // F_SETLKW (set lock and wait)
// don't mess with file locking... just act like it's OK
warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
return 0;
return SyscallReturn(0);
default:
warn("Unknown fcntl command %d\n", cmd);
return 0;
return SyscallReturn(0);
}
}

124
arch/alpha/alpha_tru64_process.cc
View file

@ -476,7 +476,7 @@ class Tru64 {
static const char *hostname;
/// Target uname() handler.
static int
static SyscallReturn
unameFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -489,12 +489,12 @@ class Tru64 {
strcpy(name->machine, "alpha");
name.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
/// Target getsysyinfo() handler.
static int
static SyscallReturn
getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -507,21 +507,21 @@ class Tru64 {
TypedBufferArg<uint32_t> max_cpu(xc->getSyscallArg(1));
*max_cpu = process->numCpus();
max_cpu.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_CPUS_IN_BOX: {
TypedBufferArg<uint32_t> cpus_in_box(xc->getSyscallArg(1));
*cpus_in_box = process->numCpus();
cpus_in_box.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_PHYSMEM: {
TypedBufferArg<uint64_t> physmem(xc->getSyscallArg(1));
*physmem = 1024 * 1024; // physical memory in KB
physmem.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_CPU_INFO: {
@ -538,14 +538,14 @@ class Tru64 {
infop->mhz = 667;
infop.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_PROC_TYPE: {
TypedBufferArg<uint64_t> proc_type(xc->getSyscallArg(1));
*proc_type = 11;
proc_type.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_PLATFORM_NAME: {
@ -554,14 +554,14 @@ class Tru64 {
"COMPAQ Professional Workstation XP1000",
nbytes);
bufArg.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
case Tru64::GSI_CLK_TCK: {
TypedBufferArg<uint64_t> clk_hz(xc->getSyscallArg(1));
*clk_hz = 1024;
clk_hz.copyOut(xc->mem);
return 1;
return SyscallReturn(1);
}
default:
@ -570,18 +570,18 @@ class Tru64 {
break;
}
return 0;
return SyscallReturn(0);
}
/// Target fnctl() handler.
static int
static SyscallReturn
fcntlFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
int fd = xc->getSyscallArg(0);
if (fd < 0 || process->sim_fd(fd) < 0)
return -EBADF;
return SyscallReturn(-EBADF);
int cmd = xc->getSyscallArg(1);
switch (cmd) {
@ -589,18 +589,18 @@ class Tru64 {
// if we really wanted to support this, we'd need to do it
// in the target fd space.
warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
return -EMFILE;
return SyscallReturn(-EMFILE);
case 1: // F_GETFD (get close-on-exec flag)
case 2: // F_SETFD (set close-on-exec flag)
return 0;
return SyscallReturn(0);
case 3: // F_GETFL (get file flags)
case 4: // F_SETFL (set file flags)
// not sure if this is totally valid, but we'll pass it through
// to the underlying OS
warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
return fcntl(process->sim_fd(fd), cmd);
return SyscallReturn(fcntl(process->sim_fd(fd), cmd));
// return 0;
case 7: // F_GETLK (get lock)
@ -608,17 +608,17 @@ class Tru64 {
case 9: // F_SETLKW (set lock and wait)
// don't mess with file locking... just act like it's OK
warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
return 0;
return SyscallReturn(0);
default:
warn("Unknown fcntl command %d\n", cmd);
return 0;
return SyscallReturn(0);
}
}
/// Target getdirentries() handler.
static int
static SyscallReturn
getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -638,7 +638,7 @@ class Tru64 {
// check for error
if (host_result < 0) {
delete [] host_buf;
return -errno;
return SyscallReturn(-errno);
}
// no error: copy results back to target space
@ -669,11 +669,11 @@ class Tru64 {
*basep = host_basep;
basep.copyOut(xc->mem);
return (tgt_buf_ptr - tgt_buf);
return SyscallReturn(tgt_buf_ptr - tgt_buf);
}
/// Target sigreturn() handler.
static int
static SyscallReturn
sigreturnFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -695,11 +695,11 @@ class Tru64 {
regs->miscRegs.fpcr = sc->sc_fpcr;
return 0;
return SyscallReturn(0);
}
/// Target table() handler.
static int
static SyscallReturn
tableFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -712,7 +712,7 @@ class Tru64 {
switch (id) {
case Tru64::TBL_SYSINFO: {
if (index != 0 || nel != 1 || lel != sizeof(Tru64::tbl_sysinfo))
return -EINVAL;
return SyscallReturn(-EINVAL);
TypedBufferArg<Tru64::tbl_sysinfo> elp(xc->getSyscallArg(2));
const int clk_hz = one_million;
@ -726,12 +726,12 @@ class Tru64 {
elp->si_boottime = seconds_since_epoch; // seconds since epoch?
elp->si_max_procs = process->numCpus();
elp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
default:
cerr << "table(): id " << id << " unknown." << endl;
return -EINVAL;
return SyscallReturn(-EINVAL);
}
}
@ -749,7 +749,7 @@ class Tru64 {
//
/// Create a stack region for a thread.
static int
static SyscallReturn
stack_createFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -766,7 +766,7 @@ class Tru64 {
argp.copyOut(xc->mem);
}
return 0;
return SyscallReturn(0);
}
/// NXM library version stamp.
@ -776,7 +776,7 @@ class Tru64 {
/// This call sets up the interface between the user and kernel
/// schedulers by creating a shared-memory region. The shared memory
/// region has several structs, some global, some per-RAD, some per-VP.
static int
static SyscallReturn
nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -877,7 +877,7 @@ class Tru64 {
*configptr_ptr = config_addr;
configptr_ptr.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
/// Initialize execution context.
@ -899,7 +899,7 @@ class Tru64 {
}
/// Create thread.
static int
static SyscallReturn
nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -946,7 +946,7 @@ class Tru64 {
*kidp = 99;
kidp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
} else if (attrp->type == Tru64::NXM_TYPE_VP) {
// A real "virtual processor" kernel thread. Need to fork
// this thread on another CPU.
@ -994,7 +994,7 @@ class Tru64 {
*kidp = thread_index;
kidp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
}
@ -1007,19 +1007,19 @@ class Tru64 {
abort();
}
return 0;
return SyscallReturn(0);
}
/// Thread idle call (like yield()).
static int
static SyscallReturn
nxm_idleFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
return 0;
return SyscallReturn(0);
}
/// Block thread.
static int
static SyscallReturn
nxm_thread_blockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1032,11 +1032,11 @@ class Tru64 {
cout << xc->cpu->name() << ": nxm_thread_block " << tid << " " << secs
<< " " << flags << " " << action << " " << usecs << endl;
return 0;
return SyscallReturn(0);
}
/// block.
static int
static SyscallReturn
nxm_blockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1053,11 +1053,11 @@ class Tru64 {
<< " " << secs << " " << usecs
<< " " << flags << endl;
return 0;
return SyscallReturn(0);
}
/// Unblock thread.
static int
static SyscallReturn
nxm_unblockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1066,11 +1066,11 @@ class Tru64 {
cout << xc->cpu->name() << ": nxm_unblock "
<< hex << uaddr << dec << endl;
return 0;
return SyscallReturn(0);
}
/// Switch thread priority.
static int
static SyscallReturn
swtch_priFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1081,7 +1081,7 @@ class Tru64 {
//
// Since we assume at most one "kernel" thread per CPU, it's
// always safe to return false here.
return false;
return SyscallReturn(0); //false;
}
@ -1154,7 +1154,7 @@ class Tru64 {
}
/// Lock acquire syscall handler.
static int
static SyscallReturn
m5_mutex_lockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1165,11 +1165,11 @@ class Tru64 {
// Return 0 since we will always return to the user with the lock
// acquired. We will just keep the context inactive until that is
// true.
return 0;
return SyscallReturn(0);
}
/// Try lock (non-blocking).
static int
static SyscallReturn
m5_mutex_trylockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1182,14 +1182,14 @@ class Tru64 {
// lock is free: grab it
*lockp = 1;
lockp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
} else {
return 1;
return SyscallReturn(1);
}
}
/// Unlock syscall handler.
static int
static SyscallReturn
m5_mutex_unlockFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1197,11 +1197,11 @@ class Tru64 {
m5_unlock_mutex(uaddr, process, xc);
return 0;
return SyscallReturn(0);
}
/// Signal ocndition.
static int
static SyscallReturn
m5_cond_signalFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1210,11 +1210,11 @@ class Tru64 {
// Wake up one process waiting on the condition variable.
activate_waiting_context(cond_addr, process);
return 0;
return SyscallReturn(0);
}
/// Wake up all processes waiting on the condition variable.
static int
static SyscallReturn
m5_cond_broadcastFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1222,11 +1222,11 @@ class Tru64 {
activate_waiting_context(cond_addr, process, true);
return 0;
return SyscallReturn(0);
}
/// Wait on a condition.
static int
static SyscallReturn
m5_cond_waitFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1244,18 +1244,18 @@ class Tru64 {
process->waitList.push_back(Process::WaitRec(cond_addr, xc));
xc->suspend();
return 0;
return SyscallReturn(0);
}
/// Thread exit.
static int
static SyscallReturn
m5_thread_exitFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
assert(xc->status() == ExecContext::Active);
xc->deallocate();
return 0;
return SyscallReturn(0);
}
/// Array of syscall descriptors for Mach syscalls, indexed by
@ -1291,7 +1291,7 @@ class Tru64 {
}
/// Indirect syscall invocation (call #0).
static int
static SyscallReturn
indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -1302,7 +1302,7 @@ class Tru64 {
doSyscall(new_callnum, process, xc);
return 0;
return SyscallReturn(0);
}
}; // class Tru64

37
arch/alpha/isa_traits.hh
View file

@ -286,6 +286,43 @@ const int ArgumentReg1 = TheISA::ArgumentReg1;
const int BranchPredAddrShiftAmt = TheISA::BranchPredAddrShiftAmt;
const int MaxAddr = (Addr)-1;
#ifndef FULL_SYSTEM
class SyscallReturn {
public:
template <class T>
SyscallReturn(T v, bool s)
{
retval = (uint64_t)v;
success = s;
}
template <class T>
SyscallReturn(T v)
{
success = (v >= 0);
retval = (uint64_t)v;
}
~SyscallReturn() {}
SyscallReturn& operator=(const SyscallReturn& s) {
retval = s.retval;
success = s.success;
return *this;
}
bool successful() { return success; }
uint64_t value() { return retval; }
private:
uint64_t retval;
bool success;
};
#endif
#ifdef FULL_SYSTEM
typedef TheISA::InternalProcReg InternalProcReg;
const int NumInternalProcRegs = TheISA::NumInternalProcRegs;

3
configs/boot/micro_memlat2mb.rcS Normal file
View file

@ -0,0 +1,3 @@
/benchmarks/micros/lmbench/bin/alphaev6-linux-gnu/lat_mem_rd_2MB 2 64
m5 exit

3
configs/boot/micro_memlat8mb.rcS Normal file
View file

@ -0,0 +1,3 @@
/benchmarks/micros/lmbench/bin/alphaev6-linux-gnu/lat_mem_rd_8MB 8 64
m5 exit

2
configs/boot/micro_syscall.rcS
View file

@ -1,3 +1,3 @@
/benchmarks/micros/lmbench/bin/alphaev6-linux-gnu/lat_syscall null
/benchmarks/micros/lmbench/bin/alphaev6-linux-gnu/lat_syscall read
m5 exit

3
configs/boot/micro_tlblat.rcS Normal file
View file

@ -0,0 +1,3 @@
/benchmarks/micros/lmbench/bin/alphaev6-linux-gnu/lat_mem_rd_2MB 2 8192
m5 exit

8
cpu/exec_context.hh
View file

@ -435,20 +435,20 @@ class ExecContext
regs.intRegFile[ArgumentReg0 + i] = val;
}
void setSyscallReturn(int64_t return_value)
void setSyscallReturn(SyscallReturn return_value)
{
// check for error condition. Alpha syscall convention is to
// indicate success/failure in reg a3 (r19) and put the
// return value itself in the standard return value reg (v0).
const int RegA3 = 19; // only place this is used
if (return_value >= 0) {
if (return_value.successful()) {
// no error
regs.intRegFile[RegA3] = 0;
regs.intRegFile[ReturnValueReg] = return_value;
regs.intRegFile[ReturnValueReg] = return_value.value();
} else {
// got an error, return details
regs.intRegFile[RegA3] = (IntReg) -1;
regs.intRegFile[ReturnValueReg] = -return_value;
regs.intRegFile[ReturnValueReg] = -return_value.value();
}
}

28
objects/BaseCPU.mpy
View file

@ -4,11 +4,13 @@ simobj BaseCPU(SimObject):
icache = Param.BaseMem(NULL, "L1 instruction cache object")
dcache = Param.BaseMem(NULL, "L1 data cache object")
dtb = Param.AlphaDTB("Data TLB")
itb = Param.AlphaITB("Instruction TLB")
mem = Param.FunctionalMemory("memory")
system = Param.BaseSystem(Super, "system object")
workload = VectorParam.Process("processes to run")
if Bool._convert(env.get('FULL_SYSTEM', 'False')):
dtb = Param.AlphaDTB("Data TLB")
itb = Param.AlphaITB("Instruction TLB")
mem = Param.FunctionalMemory("memory")
system = Param.BaseSystem(Super, "system object")
else:
workload = VectorParam.Process("processes to run")
max_insts_all_threads = Param.Counter(0,
"terminate when all threads have reached this inst count")
@ -21,19 +23,3 @@ simobj BaseCPU(SimObject):
defer_registration = Param.Bool(False,
"defer registration with system (for sampling)")
def check(self):
has_workload = self._hasvalue('workload')
has_dtb = self._hasvalue('dtb')
has_itb = self._hasvalue('itb')
has_mem = self._hasvalue('mem')
has_system = self._hasvalue('system')
if has_workload:
self.dtb.disable = True
self.itb.disable = True
self.mem.disable = True
self.system.disable = True
if has_dtb or has_itb or has_mem or has_system:
self.workload.disable = True

17
sim/process.cc
View file

@ -65,14 +65,14 @@ using namespace std;
// current number of allocated processes
int num_processes = 0;
Process::Process(const string &name,
Process::Process(const string &nm,
int stdin_fd, // initial I/O descriptors
int stdout_fd,
int stderr_fd)
: SimObject(name)
: SimObject(nm)
{
// allocate memory space
memory = new MainMemory(name + ".MainMem");
memory = new MainMemory(nm + ".MainMem");
// allocate initial register file
init_regs = new RegFile;
@ -88,6 +88,7 @@ Process::Process(const string &name,
fd_map[i] = -1;
}
mmap_start = mmap_end = 0;
// other parameters will be initialized when the program is loaded
}
@ -252,10 +253,10 @@ copyStringArray(vector<string> &strings, Addr array_ptr, Addr data_ptr,
memory->access(Write, array_ptr, &data_ptr, sizeof(Addr));
}
LiveProcess::LiveProcess(const string &name, ObjectFile *objFile,
LiveProcess::LiveProcess(const string &nm, ObjectFile *objFile,
int stdin_fd, int stdout_fd, int stderr_fd,
vector<string> &argv, vector<string> &envp)
: Process(name, stdin_fd, stdout_fd, stderr_fd)
: Process(nm, stdin_fd, stdout_fd, stderr_fd)
{
prog_fname = argv[0];
@ -339,7 +340,7 @@ LiveProcess::LiveProcess(const string &name, ObjectFile *objFile,
LiveProcess *
LiveProcess::create(const string &name,
LiveProcess::create(const string &nm,
int stdin_fd, int stdout_fd, int stderr_fd,
vector<string> &argv, vector<string> &envp)
{
@ -353,13 +354,13 @@ LiveProcess::create(const string &name,
if (objFile->getArch() == ObjectFile::Alpha) {
switch (objFile->getOpSys()) {
case ObjectFile::Tru64:
process = new AlphaTru64Process(name, objFile,
process = new AlphaTru64Process(nm, objFile,
stdin_fd, stdout_fd, stderr_fd,
argv, envp);
break;
case ObjectFile::Linux:
process = new AlphaLinuxProcess(name, objFile,
process = new AlphaLinuxProcess(nm, objFile,
stdin_fd, stdout_fd, stderr_fd,
argv, envp);
break;

7
sim/process.hh
View file

@ -42,6 +42,7 @@
#include "sim/sim_object.hh"
#include "sim/stats.hh"
#include "base/statistics.hh"
#include "base/trace.hh"
class ExecContext;
class FunctionalMemory;
@ -104,7 +105,7 @@ class Process : public SimObject
protected:
// constructor
Process(const std::string &name,
Process(const std::string &nm,
int stdin_fd, // initial I/O descriptors
int stdout_fd,
int stderr_fd);
@ -175,7 +176,7 @@ class ObjectFile;
class LiveProcess : public Process
{
protected:
LiveProcess(const std::string &name, ObjectFile *objFile,
LiveProcess(const std::string &nm, ObjectFile *objFile,
int stdin_fd, int stdout_fd, int stderr_fd,
std::vector<std::string> &argv,
std::vector<std::string> &envp);
@ -184,7 +185,7 @@ class LiveProcess : public Process
// 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(const std::string &name,
static LiveProcess *create(const std::string &nm,
int stdin_fd, int stdout_fd, int stderr_fd,
std::vector<std::string> &argv,
std::vector<std::string> &envp);

5
sim/pyconfig/SConscript
View file

@ -147,6 +147,7 @@ def MakeEmbeddedPyFile(target, source, env):
def MakeDefinesPyFile(target, source, env):
target = file(str(target[0]), 'w')
print >>target, "import os"
defines = env['CPPDEFINES']
if isinstance(defines, list):
for var in defines:
@ -158,11 +159,11 @@ def MakeDefinesPyFile(target, source, env):
if not isinstance(key, basestring):
panic("invalid type for define: %s" % type(key))
print >>target, "env['%s'] = '%s'" % (key, val)
print >>target, "os.environ['%s'] = '%s'" % (key, val)
elif isinstance(defines, dict):
for key,val in defines.iteritems():
print >>target, "env['%s'] = '%s'" % (key, val)
print >>target, "os.environ['%s'] = '%s'" % (key, val)
else:
panic("invalid type for defines: %s" % type(defines))

35
sim/pyconfig/m5config.py
View file

@ -246,7 +246,6 @@ class MetaConfigNode(type):
cls._params = {}
cls._values = {}
cls._enums = {}
cls._disable = {}
cls._bases = [c for c in cls.__mro__ if isConfigNode(c)]
cls._anon_subclass_counter = 0
@ -382,15 +381,6 @@ class MetaConfigNode(type):
def _setvalue(cls, name, value):
cls._values[name] = value
def _getdisable(cls, name):
for c in cls._bases:
if c._disable.has_key(name):
return c._disable[name]
return False
def _setdisable(cls, name, value):
cls._disable[name] = value
def __getattr__(cls, attr):
if cls._isvalue(attr):
return Value(cls, attr)
@ -465,9 +455,6 @@ class MetaConfigNode(type):
cls.check()
for key,value in cls._getvalues().iteritems():
if cls._getdisable(key):
continue
if isConfigNode(value):
cls.add_child(instance, key, value)
if issequence(value):
@ -477,15 +464,11 @@ class MetaConfigNode(type):
for pname,param in cls._getparams().iteritems():
try:
if cls._getdisable(pname):
continue
try:
value = cls._getvalue(pname)
except:
print 'Error getting %s' % pname
raise
value = cls._getvalue(pname)
except:
panic('Error getting %s' % pname)
try:
if isConfigNode(value):
value = instance.child_objects[value]
elif issequence(value):
@ -814,16 +797,10 @@ class Value(object):
return self.obj._getvalue(self.attr)
def __setattr__(self, attr, value):
if attr == 'disable':
self.obj._setdisable(self.attr, value)
else:
setattr(self._getattr(), attr, value)
setattr(self._getattr(), attr, value)
def __getattr__(self, attr):
if attr == 'disable':
return self.obj._getdisable(self.attr)
else:
return getattr(self._getattr(), attr)
return getattr(self._getattr(), attr)
def __getitem__(self, index):
return self._getattr().__getitem__(index)

67
sim/syscall_emul.cc
View file

@ -47,17 +47,17 @@ SyscallDesc::doSyscall(int callnum, Process *process, ExecContext *xc)
DPRINTFR(SyscallVerbose, "%s: syscall %s called\n",
xc->cpu->name(), name);
int retval = (*funcPtr)(this, callnum, process, xc);
SyscallReturn retval = (*funcPtr)(this, callnum, process, xc);
DPRINTFR(SyscallVerbose, "%s: syscall %s returns %d\n",
xc->cpu->name(), name, retval);
xc->cpu->name(), name, retval.value());
if (!((flags & SyscallDesc::SuppressReturnValue) && retval == 0))
if (!(flags & SyscallDesc::SuppressReturnValue))
xc->setSyscallReturn(retval);
}
int
SyscallReturn
unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -70,7 +70,7 @@ unimplementedFunc(SyscallDesc *desc, int callnum, Process *process,
}
int
SyscallReturn
ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -79,47 +79,49 @@ ignoreFunc(SyscallDesc *desc, int callnum, Process *process,
<< ", " << xc->getSyscallArg(1)
<< ", ...)" << endl;
return 0;
return SyscallReturn(0);
}
int
SyscallReturn
exitFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
new SimExitEvent("syscall caused exit", xc->getSyscallArg(0) & 0xff);
return 1;
return SyscallReturn(1);
}
int
SyscallReturn
getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
return VMPageSize;
return SyscallReturn(VMPageSize);
}
int
SyscallReturn
obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
// change brk addr to first arg
Addr new_brk = xc->getSyscallArg(0);
if (new_brk != 0)
{
p->brk_point = xc->getSyscallArg(0);
return p->brk_point;
}
return SyscallReturn(p->brk_point);
}
int
SyscallReturn
closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
int fd = p->sim_fd(xc->getSyscallArg(0));
return close(fd);
return SyscallReturn(close(fd));
}
int
SyscallReturn
readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
int fd = p->sim_fd(xc->getSyscallArg(0));
@ -131,10 +133,10 @@ readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
if (bytes_read != -1)
bufArg.copyOut(xc->mem);
return bytes_read;
return SyscallReturn(bytes_read);
}
int
SyscallReturn
writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
int fd = p->sim_fd(xc->getSyscallArg(0));
@ -147,11 +149,11 @@ writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
fsync(fd);
return bytes_written;
return SyscallReturn(bytes_written);
}
int
SyscallReturn
lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
int fd = p->sim_fd(xc->getSyscallArg(0));
@ -160,21 +162,22 @@ lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
off_t result = lseek(fd, offs, whence);
return (result == (off_t)-1) ? -errno : result;
return (result == (off_t)-1) ? SyscallReturn(-errno) :
SyscallReturn(result);
}
int
SyscallReturn
munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
// given that we don't really implement mmap, munmap is really easy
return 0;
return SyscallReturn(0);
}
const char *hostname = "m5.eecs.umich.edu";
int
SyscallReturn
gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
int name_len = xc->getSyscallArg(1);
@ -184,35 +187,35 @@ gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
name.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
int
SyscallReturn
unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
std::string path;
if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
return -EFAULT;
return (TheISA::IntReg)-EFAULT;
int result = unlink(path.c_str());
return (result == -1) ? -errno : result;
return (result == -1) ? SyscallReturn(-errno) : SyscallReturn(result);
}
int
SyscallReturn
renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
std::string old_name;
if (xc->mem->readString(old_name, xc->getSyscallArg(0)) != No_Fault)
return -EFAULT;
return SyscallReturn(-EFAULT);
std::string new_name;
if (xc->mem->readString(new_name, xc->getSyscallArg(1)) != No_Fault)
return -EFAULT;
return SyscallReturn(-EFAULT);
int result = rename(old_name.c_str(),new_name.c_str());
return (result == -1) ? -errno : result;
int64_t result = rename(old_name.c_str(),new_name.c_str());
return (result == -1) ? SyscallReturn(-errno) : SyscallReturn(result);
}

82
sim/syscall_emul.hh
View file

@ -54,7 +54,7 @@ class SyscallDesc {
public:
/// Typedef for target syscall handler functions.
typedef int (*FuncPtr)(SyscallDesc *, int num,
typedef SyscallReturn (*FuncPtr)(SyscallDesc *, int num,
Process *, ExecContext *);
const char *name; //!< Syscall name (e.g., "open").
@ -158,46 +158,46 @@ class TypedBufferArg : public BaseBufferArg
/// Handler for unimplemented syscalls that we haven't thought about.
int unimplementedFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn unimplementedFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// 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.
int ignoreFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn ignoreFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target exit() handler: terminate simulation.
int exitFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn exitFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target getpagesize() handler.
int getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn getpagesizeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target obreak() handler: set brk address.
int obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn obreakFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target close() handler.
int closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn closeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target read() handler.
int readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn readFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target write() handler.
int writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn writeFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target lseek() handler.
int lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn lseekFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target munmap() handler.
int munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn munmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target gethostname() handler.
int gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn gethostnameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target unlink() handler.
int unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// Target rename() handler.
int renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
SyscallReturn renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc);
/// This struct is used to build an target-OS-dependent table that
/// maps the target's open() flags to the host open() flags.
@ -240,7 +240,7 @@ getElapsedTime(T1 &sec, T2 &usec)
/// only to find out if their stdout is a tty, to determine whether to
/// do line or block buffering.
template <class OS>
int
SyscallReturn
ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -251,7 +251,7 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
if (fd < 0 || process->sim_fd(fd) < 0) {
// doesn't map to any simulator fd: not a valid target fd
return -EBADF;
return SyscallReturn(-EBADF);
}
switch (req) {
@ -263,7 +263,7 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
case OS::TIOCGETC:
case OS::TIOCGETS:
case OS::TIOCGETA:
return -ENOTTY;
return SyscallReturn(-ENOTTY);
default:
fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...) @ 0x%llx\n", fd, req, xc->readPC());
@ -272,20 +272,20 @@ ioctlFunc(SyscallDesc *desc, int callnum, Process *process,
/// Target open() handler.
template <class OS>
int
SyscallReturn
openFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
std::string path;
if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
return -EFAULT;
return SyscallReturn(-EFAULT);
if (path == "/dev/sysdev0") {
// This is a memory-mapped high-resolution timer device on Alpha.
// We don't support it, so just punt.
DCOUT(SyscallWarnings) << "Ignoring open(" << path << ", ...)" << std::endl;
return -ENOENT;
return SyscallReturn(-ENOENT);
}
int tgtFlags = xc->getSyscallArg(1);
@ -311,58 +311,58 @@ openFunc(SyscallDesc *desc, int callnum, Process *process,
// open the file
int fd = open(path.c_str(), hostFlags, mode);
return (fd == -1) ? -errno : process->open_fd(fd);
return (fd == -1) ? SyscallReturn(-errno) : SyscallReturn(process->open_fd(fd));
}
/// Target stat() handler.
template <class OS>
int
SyscallReturn
statFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
std::string path;
if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
return -EFAULT;
return SyscallReturn(-EFAULT);
struct stat hostBuf;
int result = stat(path.c_str(), &hostBuf);
if (result < 0)
return -errno;
return SyscallReturn(errno);
OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
return 0;
return SyscallReturn(0);
}
/// Target lstat() handler.
template <class OS>
int
SyscallReturn
lstatFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
std::string path;
if (xc->mem->readString(path, xc->getSyscallArg(0)) != No_Fault)
return -EFAULT;
return SyscallReturn(-EFAULT);
struct stat hostBuf;
int result = lstat(path.c_str(), &hostBuf);
if (result < 0)
return -errno;
return SyscallReturn(-errno);
OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
return 0;
return SyscallReturn(0);
}
/// Target fstat() handler.
template <class OS>
int
SyscallReturn
fstatFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -371,17 +371,17 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
// DPRINTFR(SyscallVerbose, "fstat(%d, ...)\n", fd);
if (fd < 0)
return -EBADF;
return SyscallReturn(-EBADF);
struct stat hostBuf;
int result = fstat(fd, &hostBuf);
if (result < 0)
return -errno;
return SyscallReturn(-errno);
OS::copyOutStatBuf(xc->mem, xc->getSyscallArg(1), &hostBuf);
return 0;
return SyscallReturn(0);
}
@ -398,7 +398,7 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process,
/// file descriptor, and fail (or implement!) a non-anonymous mmap to
/// anything else.
template <class OS>
int
SyscallReturn
mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{
Addr start = xc->getSyscallArg(0);
@ -419,12 +419,12 @@ mmapFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
"This will break if not /dev/zero.", xc->getSyscallArg(4));
}
return start;
return SyscallReturn(start);
}
/// Target getrlimit() handler.
template <class OS>
int
SyscallReturn
getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -444,12 +444,12 @@ getrlimitFunc(SyscallDesc *desc, int callnum, Process *process,
}
rlp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
/// Target gettimeofday() handler.
template <class OS>
int
SyscallReturn
gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -460,13 +460,13 @@ gettimeofdayFunc(SyscallDesc *desc, int callnum, Process *process,
tp.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
/// Target getrusage() function.
template <class OS>
int
SyscallReturn
getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
ExecContext *xc)
{
@ -501,7 +501,7 @@ getrusageFunc(SyscallDesc *desc, int callnum, Process *process,
rup.copyOut(xc->mem);
return 0;
return SyscallReturn(0);
}
#endif // __SIM_SYSCALL_EMUL_HH__