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

Get rid of "Functional" suffix from (read|write)(Blob|String) functions.

Browse source 
--HG--
extra : convert_revision : 1456308af0fd686dff53ec1baddd7747354e1c0a
This commit is contained in:
Steve Reinhardt 2006-03-12 16:38:16 -05:00
parent 159cee1719
commit 2d9c9dba37
8 changed files with 73 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
base/loader/object_file.cc
View file

@ -74,11 +74,11 @@ ObjectFile::loadSection(Section *sec, TranslatingPort *memPort, bool loadPhys)
} }
if (sec->fileImage) { if (sec->fileImage) {
memPort->writeBlobFunctional(addr, sec->fileImage, sec->size, true); memPort->writeBlob(addr, sec->fileImage, sec->size, true);
} }
else { else {
// no image: must be bss // no image: must be bss
memPort->memsetBlobFunctional(addr, 0, sec->size, true); memPort->memsetBlob(addr, 0, sec->size, true);
} }
} }
return true; return true;

6
mem/port.cc
View file

@ -52,19 +52,19 @@ Port::blobHelper(Addr addr, uint8_t *p, int size, Command cmd)
} }
void void
Port::writeBlobFunctional(Addr addr, uint8_t *p, int size) Port::writeBlob(Addr addr, uint8_t *p, int size)
{ {
blobHelper(addr, p, size, Write); blobHelper(addr, p, size, Write);
} }
void void
Port::readBlobFunctional(Addr addr, uint8_t *p, int size) Port::readBlob(Addr addr, uint8_t *p, int size)
{ {
blobHelper(addr, p, size, Read); blobHelper(addr, p, size, Read);
} }
void void
Port::memsetBlobFunctional(Addr addr, uint8_t val, int size) Port::memsetBlob(Addr addr, uint8_t val, int size)
{ {
// quick and dirty... // quick and dirty...
uint8_t *buf = new uint8_t[size]; uint8_t *buf = new uint8_t[size];

21
mem/port.hh
View file

@ -191,29 +191,26 @@ class Port
void getPeerAddressRanges(AddrRangeList &range_list, bool &owner) void getPeerAddressRanges(AddrRangeList &range_list, bool &owner)
{ peer->getDeviceAddressRanges(range_list, owner); } { peer->getDeviceAddressRanges(range_list, owner); }
// Do we need similar wrappers for sendAtomic()? If not, should /** This function is a wrapper around sendFunctional()
// we drop the "Functional" from the names? that breaks a larger, arbitrarily aligned access into
appropriate chunks. The default implementation can use
getBlockSize() to determine the block size and go from there.
*/
void readBlob(Addr addr, uint8_t *p, int size);
/** This function is a wrapper around sendFunctional() /** This function is a wrapper around sendFunctional()
that breaks a larger, arbitrarily aligned access into that breaks a larger, arbitrarily aligned access into
appropriate chunks. The default implementation can use appropriate chunks. The default implementation can use
getBlockSize() to determine the block size and go from there. getBlockSize() to determine the block size and go from there.
*/ */
void readBlobFunctional(Addr addr, uint8_t *p, int size); void writeBlob(Addr addr, uint8_t *p, int size);
/** This function is a wrapper around sendFunctional()
that breaks a larger, arbitrarily aligned access into
appropriate chunks. The default implementation can use
getBlockSize() to determine the block size and go from there.
*/
void writeBlobFunctional(Addr addr, uint8_t *p, int size);
/** Fill size bytes starting at addr with byte value val. This /** Fill size bytes starting at addr with byte value val. This
should not need to be virtual, since it can be implemented in should not need to be virtual, since it can be implemented in
terms of writeBlobFunctional(). However, it shouldn't be terms of writeBlob(). However, it shouldn't be
performance-critical either, so it could be if we wanted to. performance-critical either, so it could be if we wanted to.
*/ */
void memsetBlobFunctional(Addr addr, uint8_t val, int size); void memsetBlob(Addr addr, uint8_t val, int size);
private: private:

54
mem/translating_port.cc
View file

@ -42,7 +42,7 @@ TranslatingPort::~TranslatingPort()
{ } { }
bool bool
TranslatingPort::tryReadBlobFunctional(Addr addr, uint8_t *p, int size) TranslatingPort::tryReadBlob(Addr addr, uint8_t *p, int size)
{ {
Addr paddr; Addr paddr;
int prevSize = 0; int prevSize = 0;
@ -52,7 +52,7 @@ TranslatingPort::tryReadBlobFunctional(Addr addr, uint8_t *p, int size)
if (!pTable->translate(gen.addr(),paddr)) if (!pTable->translate(gen.addr(),paddr))
return false; return false;
port->readBlobFunctional(paddr, p + prevSize, gen.size()); port->readBlob(paddr, p + prevSize, gen.size());
prevSize += gen.size(); prevSize += gen.size();
} }
@ -60,16 +60,15 @@ TranslatingPort::tryReadBlobFunctional(Addr addr, uint8_t *p, int size)
} }
void void
TranslatingPort::readBlobFunctional(Addr addr, uint8_t *p, int size) TranslatingPort::readBlob(Addr addr, uint8_t *p, int size)
{ {
if (!tryReadBlobFunctional(addr, p, size)) if (!tryReadBlob(addr, p, size))
fatal("readBlobFunctional(0x%x, ...) failed", addr); fatal("readBlob(0x%x, ...) failed", addr);
} }
bool bool
TranslatingPort::tryWriteBlobFunctional(Addr addr, uint8_t *p, int size, TranslatingPort::tryWriteBlob(Addr addr, uint8_t *p, int size, bool alloc)
bool alloc)
{ {
Addr paddr; Addr paddr;
@ -87,7 +86,7 @@ TranslatingPort::tryWriteBlobFunctional(Addr addr, uint8_t *p, int size,
} }
} }
port->writeBlobFunctional(paddr, p + prevSize, gen.size()); port->writeBlob(paddr, p + prevSize, gen.size());
prevSize += gen.size(); prevSize += gen.size();
} }
@ -96,16 +95,14 @@ TranslatingPort::tryWriteBlobFunctional(Addr addr, uint8_t *p, int size,
void void
TranslatingPort::writeBlobFunctional(Addr addr, uint8_t *p, int size, TranslatingPort::writeBlob(Addr addr, uint8_t *p, int size, bool alloc)
bool alloc)
{ {
if (!tryWriteBlobFunctional(addr, p, size, alloc)) if (!tryWriteBlob(addr, p, size, alloc))
fatal("writeBlobFunctional(0x%x, ...) failed", addr); fatal("writeBlob(0x%x, ...) failed", addr);
} }
bool bool
TranslatingPort::tryMemsetBlobFunctional(Addr addr, uint8_t val, int size, TranslatingPort::tryMemsetBlob(Addr addr, uint8_t val, int size, bool alloc)
bool alloc)
{ {
Addr paddr; Addr paddr;
@ -121,23 +118,22 @@ TranslatingPort::tryMemsetBlobFunctional(Addr addr, uint8_t val, int size,
} }
} }
port->memsetBlobFunctional(paddr, val, gen.size()); port->memsetBlob(paddr, val, gen.size());
} }
return true; return true;
} }
void void
TranslatingPort::memsetBlobFunctional(Addr addr, uint8_t val, int size, TranslatingPort::memsetBlob(Addr addr, uint8_t val, int size, bool alloc)
bool alloc)
{ {
if (!tryMemsetBlobFunctional(addr, val, size, alloc)) if (!tryMemsetBlob(addr, val, size, alloc))
fatal("memsetBlobFunctional(0x%x, ...) failed", addr); fatal("memsetBlob(0x%x, ...) failed", addr);
} }
bool bool
TranslatingPort::tryWriteStringFunctional(Addr addr, const char *str) TranslatingPort::tryWriteString(Addr addr, const char *str)
{ {
Addr paddr,vaddr; Addr paddr,vaddr;
uint8_t c; uint8_t c;
@ -149,21 +145,21 @@ TranslatingPort::tryWriteStringFunctional(Addr addr, const char *str)
if (!pTable->translate(vaddr++,paddr)) if (!pTable->translate(vaddr++,paddr))
return false; return false;
port->writeBlobFunctional(paddr, &c, 1); port->writeBlob(paddr, &c, 1);
} while (c); } while (c);
return true; return true;
} }
void void
TranslatingPort::writeStringFunctional(Addr addr, const char *str) TranslatingPort::writeString(Addr addr, const char *str)
{ {
if (!tryWriteStringFunctional(addr, str)) if (!tryWriteString(addr, str))
fatal("writeStringFunctional(0x%x, ...) failed", addr); fatal("writeString(0x%x, ...) failed", addr);
} }
bool bool
TranslatingPort::tryReadStringFunctional(std::string &str, Addr addr) TranslatingPort::tryReadString(std::string &str, Addr addr)
{ {
Addr paddr,vaddr; Addr paddr,vaddr;
uint8_t c; uint8_t c;
@ -174,7 +170,7 @@ TranslatingPort::tryReadStringFunctional(std::string &str, Addr addr)
if (!pTable->translate(vaddr++,paddr)) if (!pTable->translate(vaddr++,paddr))
return false; return false;
port->readBlobFunctional(paddr, &c, 1); port->readBlob(paddr, &c, 1);
str += c; str += c;
} while (c); } while (c);
@ -182,9 +178,9 @@ TranslatingPort::tryReadStringFunctional(std::string &str, Addr addr)
} }
void void
TranslatingPort::readStringFunctional(std::string &str, Addr addr) TranslatingPort::readString(std::string &str, Addr addr)
{ {
if (!tryReadStringFunctional(str, addr)) if (!tryReadString(str, addr))
fatal("readStringFunctional(0x%x, ...) failed", addr); fatal("readString(0x%x, ...) failed", addr);
} }

24
mem/translating_port.hh
View file

@ -48,21 +48,17 @@ class TranslatingPort
virtual ~TranslatingPort(); virtual ~TranslatingPort();
public: public:
bool tryReadBlobFunctional(Addr addr, uint8_t *p, int size); bool tryReadBlob(Addr addr, uint8_t *p, int size);
bool tryWriteBlobFunctional(Addr addr, uint8_t *p, int size, bool tryWriteBlob(Addr addr, uint8_t *p, int size, bool alloc = false);
bool alloc = false); bool tryMemsetBlob(Addr addr, uint8_t val, int size, bool alloc = false);
bool tryMemsetBlobFunctional(Addr addr, uint8_t val, int size, bool tryWriteString(Addr addr, const char *str);
bool alloc = false); bool tryReadString(std::string &str, Addr addr);
bool tryWriteStringFunctional(Addr addr, const char *str);
bool tryReadStringFunctional(std::string &str, Addr addr);
void readBlobFunctional(Addr addr, uint8_t *p, int size); void readBlob(Addr addr, uint8_t *p, int size);
void writeBlobFunctional(Addr addr, uint8_t *p, int size, void writeBlob(Addr addr, uint8_t *p, int size, bool alloc = false);
bool alloc = false); void memsetBlob(Addr addr, uint8_t val, int size, bool alloc = false);
void memsetBlobFunctional(Addr addr, uint8_t val, int size, void writeString(Addr addr, const char *str);
bool alloc = false); void readString(std::string &str, Addr addr);
void writeStringFunctional(Addr addr, const char *str);
void readStringFunctional(std::string &str, Addr addr);
}; };
#endif #endif

8
sim/process.cc
View file

@ -245,15 +245,15 @@ copyStringArray(vector<string> &strings, Addr array_ptr, Addr data_ptr,
Addr data_ptr_swap; Addr data_ptr_swap;
for (int i = 0; i < strings.size(); ++i) { for (int i = 0; i < strings.size(); ++i) {
data_ptr_swap = htog(data_ptr); data_ptr_swap = htog(data_ptr);
memPort->writeBlobFunctional(array_ptr, (uint8_t*)&data_ptr_swap, sizeof(Addr)); memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr_swap, sizeof(Addr));
memPort->writeStringFunctional(data_ptr, strings[i].c_str()); memPort->writeString(data_ptr, strings[i].c_str());
array_ptr += sizeof(Addr); array_ptr += sizeof(Addr);
data_ptr += strings[i].size() + 1; data_ptr += strings[i].size() + 1;
} }
// add NULL terminator // add NULL terminator
data_ptr = 0; data_ptr = 0;
memPort->writeBlobFunctional(array_ptr, (uint8_t*)&data_ptr, sizeof(Addr)); memPort->writeBlob(array_ptr, (uint8_t*)&data_ptr, sizeof(Addr));
} }
LiveProcess::LiveProcess(const string &nm, ObjectFile *_objFile, LiveProcess::LiveProcess(const string &nm, ObjectFile *_objFile,
@ -336,7 +336,7 @@ LiveProcess::startup()
// write contents to stack // write contents to stack
uint64_t argc = argv.size(); uint64_t argc = argv.size();
argc = htog(argc); argc = htog(argc);
initVirtMem->writeBlobFunctional(stack_min, (uint8_t*)&argc, sizeof(uint64_t)); initVirtMem->writeBlob(stack_min, (uint8_t*)&argc, sizeof(uint64_t));
copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem); copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem); copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);

10
sim/syscall_emul.cc
View file

@ -193,7 +193,7 @@ unlinkFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{ {
string path; string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return (TheISA::IntReg)-EFAULT; return (TheISA::IntReg)-EFAULT;
int result = unlink(path.c_str()); int result = unlink(path.c_str());
@ -205,12 +205,12 @@ renameFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{ {
string old_name; string old_name;
if (!xc->getMemPort()->tryReadStringFunctional(old_name, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(old_name, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
string new_name; string new_name;
if (!xc->getMemPort()->tryReadStringFunctional(new_name, xc->getSyscallArg(1))) if (!xc->getMemPort()->tryReadString(new_name, xc->getSyscallArg(1)))
return -EFAULT; return -EFAULT;
int64_t result = rename(old_name.c_str(), new_name.c_str()); int64_t result = rename(old_name.c_str(), new_name.c_str());
@ -222,7 +222,7 @@ truncateFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{ {
string path; string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
off_t length = xc->getSyscallArg(1); off_t length = xc->getSyscallArg(1);
@ -250,7 +250,7 @@ chownFunc(SyscallDesc *desc, int num, Process *p, ExecContext *xc)
{ {
string path; string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
/* XXX endianess */ /* XXX endianess */

28
sim/syscall_emul.hh
View file

@ -109,7 +109,7 @@ class BaseBufferArg {
// //
virtual bool copyIn(TranslatingPort *memport) virtual bool copyIn(TranslatingPort *memport)
{ {
memport->readBlobFunctional(addr, bufPtr, size); memport->readBlob(addr, bufPtr, size);
return true; // no EFAULT detection for now return true; // no EFAULT detection for now
} }
@ -118,7 +118,7 @@ class BaseBufferArg {
// //
virtual bool copyOut(TranslatingPort *memport) virtual bool copyOut(TranslatingPort *memport)
{ {
memport->writeBlobFunctional(addr, bufPtr, size); memport->writeBlob(addr, bufPtr, size);
return true; // no EFAULT detection for now return true; // no EFAULT detection for now
} }
@ -370,7 +370,7 @@ openFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
if (path == "/dev/sysdev0") { if (path == "/dev/sysdev0") {
@ -417,7 +417,7 @@ chmodFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
uint32_t mode = xc->getSyscallArg(1); uint32_t mode = xc->getSyscallArg(1);
@ -470,7 +470,7 @@ statFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
struct stat hostBuf; struct stat hostBuf;
@ -522,7 +522,7 @@ lstatFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
struct stat hostBuf; struct stat hostBuf;
@ -544,7 +544,7 @@ lstat64Func(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
#if BSD_HOST #if BSD_HOST
@ -596,7 +596,7 @@ statfsFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
struct statfs hostBuf; struct statfs hostBuf;
@ -646,18 +646,20 @@ writevFunc(SyscallDesc *desc, int callnum, Process *process,
return -EBADF; return -EBADF;
} }
TranslatingPort *p = xc->getMemPort();
uint64_t tiov_base = xc->getSyscallArg(1); uint64_t tiov_base = xc->getSyscallArg(1);
size_t count = xc->getSyscallArg(2); size_t count = xc->getSyscallArg(2);
struct iovec hiov[count]; struct iovec hiov[count];
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
{ {
typename OS::tgt_iovec tiov; typename OS::tgt_iovec tiov;
xc->getMemPort()->readBlobFunctional(tiov_base + i*sizeof(typename OS::tgt_iovec),(uint8_t*)
&tiov, sizeof(typename OS::tgt_iovec)); p->readBlob(tiov_base + i*sizeof(typename OS::tgt_iovec),
(uint8_t*)&tiov, sizeof(typename OS::tgt_iovec));
hiov[i].iov_len = gtoh(tiov.iov_len); hiov[i].iov_len = gtoh(tiov.iov_len);
hiov[i].iov_base = new char [hiov[i].iov_len]; hiov[i].iov_base = new char [hiov[i].iov_len];
xc->getMemPort()->readBlobFunctional(gtoh(tiov.iov_base), p->readBlob(gtoh(tiov.iov_base), (uint8_t *)hiov[i].iov_base,
(uint8_t *)hiov[i].iov_base, hiov[i].iov_len); hiov[i].iov_len);
} }
int result = writev(process->sim_fd(fd), hiov, count); int result = writev(process->sim_fd(fd), hiov, count);
@ -770,7 +772,7 @@ utimesFunc(SyscallDesc *desc, int callnum, Process *process,
{ {
std::string path; std::string path;
if (!xc->getMemPort()->tryReadStringFunctional(path, xc->getSyscallArg(0))) if (!xc->getMemPort()->tryReadString(path, xc->getSyscallArg(0)))
return -EFAULT; return -EFAULT;
TypedBufferArg<typename OS::timeval [2]> tp(xc->getSyscallArg(1)); TypedBufferArg<typename OS::timeval [2]> tp(xc->getSyscallArg(1));