objFile->loadSections(initVirtMem);
- typedef AuxVector<uint64_t> auxv_t;
- std::vector<auxv_t> auxv;
+ std::vector<AuxVector<uint64_t>> auxv;
ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile);
if (elfObject)
// seem to be a problem.
// check out _dl_aux_init() in glibc/elf/dl-support.c for details
// --Lisa
- auxv.push_back(auxv_t(M5_AT_PAGESZ, AlphaISA::PageBytes));
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 100));
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
- DPRINTF(Loader, "auxv at PHDR %08p\n", elfObject->programHeaderTable());
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PAGESZ, AlphaISA::PageBytes);
+ auxv.emplace_back(M5_AT_CLKTCK, 100);
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
+ DPRINTF(Loader, "auxv at PHDR %08p\n",
+ elfObject->programHeaderTable());
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
}
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
//Copy the aux stuff
- for (vector<auxv_t>::size_type x = 0; x < auxv.size(); x++) {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()), intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()), intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
ThreadContext *tc = system->getThreadContext(contextIds[0]);
{
int intSize = sizeof(IntType);
- typedef AuxVector<IntType> auxv_t;
- std::vector<auxv_t> auxv;
+ std::vector<AuxVector<IntType>> auxv;
string filename;
if (argv.size() < 1)
//Bits which describe the system hardware capabilities
//XXX Figure out what these should be
- auxv.push_back(auxv_t(M5_AT_HWCAP, features));
+ auxv.emplace_back(M5_AT_HWCAP, features);
//Frequency at which times() increments
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 0x64));
+ auxv.emplace_back(M5_AT_CLKTCK, 0x64);
//Whether to enable "secure mode" in the executable
- auxv.push_back(auxv_t(M5_AT_SECURE, 0));
+ auxv.emplace_back(M5_AT_SECURE, 0);
// Pointer to 16 bytes of random data
- auxv.push_back(auxv_t(M5_AT_RANDOM, 0));
+ auxv.emplace_back(M5_AT_RANDOM, 0);
//The filename of the program
- auxv.push_back(auxv_t(M5_AT_EXECFN, 0));
+ auxv.emplace_back(M5_AT_EXECFN, 0);
//The string "v71" -- ARM v7 architecture
- auxv.push_back(auxv_t(M5_AT_PLATFORM, 0));
+ auxv.emplace_back(M5_AT_PLATFORM, 0);
}
//The system page size
- auxv.push_back(auxv_t(M5_AT_PAGESZ, ArmISA::PageBytes));
- // For statically linked executables, this is the virtual address of the
- // program header tables if they appear in the executable image
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
+ auxv.emplace_back(M5_AT_PAGESZ, ArmISA::PageBytes);
+ // For statically linked executables, this is the virtual address of
+ // the program header tables if they appear in the executable image
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
// This is the size of a program header entry from the elf file.
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
// This is the number of program headers from the original elf file.
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
//XXX Figure out what this should be.
- auxv.push_back(auxv_t(M5_AT_FLAGS, 0));
+ auxv.emplace_back(M5_AT_FLAGS, 0);
//The entry point to the program
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
//Different user and group IDs
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
}
//Figure out how big the initial stack nedes to be
//Fix up the aux vectors which point to other data
for (int i = auxv.size() - 1; i >= 0; i--) {
- if (auxv[i].getHostAuxType() == M5_AT_PLATFORM) {
- auxv[i].setAuxVal(platform_base);
+ if (auxv[i].type == M5_AT_PLATFORM) {
+ auxv[i].val = platform_base;
initVirtMem.writeString(platform_base, platform.c_str());
- } else if (auxv[i].getHostAuxType() == M5_AT_EXECFN) {
- auxv[i].setAuxVal(aux_data_base);
+ } else if (auxv[i].type == M5_AT_EXECFN) {
+ auxv[i].val = aux_data_base;
initVirtMem.writeString(aux_data_base, filename.c_str());
- } else if (auxv[i].getHostAuxType() == M5_AT_RANDOM) {
- auxv[i].setAuxVal(aux_random_base);
+ } else if (auxv[i].type == M5_AT_RANDOM) {
+ auxv[i].val = aux_random_base;
// Just leave the value 0, we don't want randomness
}
}
//Copy the aux stuff
- for (int x = 0; x < auxv.size(); x++) {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()),
- intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()),
- intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
//Write out the terminating zeroed auxillary vector
- const IntType zero[2] = {0, 0};
- initVirtMem.writeBlob(auxv_array_base + 2 * intSize * auxv.size(),
- (uint8_t*)zero, 2 * intSize);
+ const AuxVector<IntType> zero(0, 0);
+ initVirtMem.write(auxv_array_end, zero);
+ auxv_array_end += sizeof(zero);
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
// load object file into target memory
objFile->loadSections(initVirtMem);
- typedef AuxVector<IntType> auxv_t;
- std::vector<auxv_t> auxv;
+ std::vector<AuxVector<IntType>> auxv;
ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile);
if (elfObject)
{
// Set the system page size
- auxv.push_back(auxv_t(M5_AT_PAGESZ, MipsISA::PageBytes));
+ auxv.emplace_back(M5_AT_PAGESZ, MipsISA::PageBytes);
// Set the frequency at which time() increments
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 100));
+ auxv.emplace_back(M5_AT_CLKTCK, 100);
// For statically linked executables, this is the virtual
// address of the program header tables if they appear in the
// executable image.
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
- DPRINTF(Loader, "auxv at PHDR %08p\n", elfObject->programHeaderTable());
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
+ DPRINTF(Loader, "auxv at PHDR %08p\n",
+ elfObject->programHeaderTable());
// This is the size of a program header entry from the elf file.
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
// This is the number of program headers from the original elf file.
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
//The entry point to the program
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
//Different user and group IDs
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
}
// Calculate how much space we need for arg & env & auxv arrays.
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
// Copy the aux vector
- for (typename vector<auxv_t>::size_type x = 0; x < auxv.size(); x++) {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()), intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()), intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
// Write out the terminating zeroed auxilliary vector
- for (unsigned i = 0; i < 2; i++) {
- const IntType zero = 0;
- const Addr addr = auxv_array_base + 2 * intSize * (auxv.size() + i);
- initVirtMem.writeBlob(addr, (uint8_t*)&zero, intSize);
- }
+ const AuxVector<IntType> zero(0, 0);
+ initVirtMem.write(auxv_array_end, zero);
+ auxv_array_end += sizeof(zero);
ThreadContext *tc = system->getThreadContext(contextIds[0]);
void
PowerProcess::argsInit(int intSize, int pageSize)
{
- typedef AuxVector<uint32_t> auxv_t;
- std::vector<auxv_t> auxv;
+ std::vector<AuxVector<uint32_t>> auxv;
string filename;
if (argv.size() < 1)
//Bits which describe the system hardware capabilities
//XXX Figure out what these should be
- auxv.push_back(auxv_t(M5_AT_HWCAP, features));
+ auxv.emplace_back(M5_AT_HWCAP, features);
//The system page size
- auxv.push_back(auxv_t(M5_AT_PAGESZ, PowerISA::PageBytes));
+ auxv.emplace_back(M5_AT_PAGESZ, PowerISA::PageBytes);
//Frequency at which times() increments
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 0x64));
- // For statically linked executables, this is the virtual address of the
- // program header tables if they appear in the executable image
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
+ auxv.emplace_back(M5_AT_CLKTCK, 0x64);
+ // For statically linked executables, this is the virtual address of
+ // the program header tables if they appear in the executable image
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
// This is the size of a program header entry from the elf file.
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
// This is the number of program headers from the original elf file.
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
//XXX Figure out what this should be.
- auxv.push_back(auxv_t(M5_AT_FLAGS, 0));
+ auxv.emplace_back(M5_AT_FLAGS, 0);
//The entry point to the program
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
//Different user and group IDs
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
//Whether to enable "secure mode" in the executable
- auxv.push_back(auxv_t(M5_AT_SECURE, 0));
+ auxv.emplace_back(M5_AT_SECURE, 0);
//The filename of the program
- auxv.push_back(auxv_t(M5_AT_EXECFN, 0));
+ auxv.emplace_back(M5_AT_EXECFN, 0);
//The string "v51" with unknown meaning
- auxv.push_back(auxv_t(M5_AT_PLATFORM, 0));
+ auxv.emplace_back(M5_AT_PLATFORM, 0);
}
//Figure out how big the initial stack nedes to be
//Fix up the aux vectors which point to other data
for (int i = auxv.size() - 1; i >= 0; i--) {
- if (auxv[i].getHostAuxType() == M5_AT_PLATFORM) {
- auxv[i].setAuxVal(platform_base);
+ if (auxv[i].type == M5_AT_PLATFORM) {
+ auxv[i].val = platform_base;
initVirtMem.writeString(platform_base, platform.c_str());
- } else if (auxv[i].getHostAuxType() == M5_AT_EXECFN) {
- auxv[i].setAuxVal(aux_data_base);
+ } else if (auxv[i].type == M5_AT_EXECFN) {
+ auxv[i].val = aux_data_base;
initVirtMem.writeString(aux_data_base, filename.c_str());
}
}
//Copy the aux stuff
- for (int x = 0; x < auxv.size(); x++)
- {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()), intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()), intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
//Write out the terminating zeroed auxilliary vector
- const uint64_t zero = 0;
- initVirtMem.writeBlob(auxv_array_base + 2 * intSize * auxv.size(),
- (uint8_t*)&zero, 2 * intSize);
+ const AuxVector<uint64_t> zero(0, 0);
+ initVirtMem.write(auxv_array_end, zero);
+ auxv_array_end += sizeof(zero);
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
stack_top -= env.size() + 1;
stack_top &= -addrSize;
- typedef AuxVector<IntType> auxv_t;
- vector<auxv_t> auxv;
+ vector<AuxVector<IntType>> auxv;
if (elfObject != nullptr) {
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
- auxv.push_back(auxv_t(M5_AT_PAGESZ, PageBytes));
- auxv.push_back(auxv_t(M5_AT_SECURE, 0));
- auxv.push_back(auxv_t(M5_AT_RANDOM, stack_top));
- auxv.push_back(auxv_t(M5_AT_NULL, 0));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
+ auxv.emplace_back(M5_AT_PAGESZ, PageBytes);
+ auxv.emplace_back(M5_AT_SECURE, 0);
+ auxv.emplace_back(M5_AT_RANDOM, stack_top);
+ auxv.emplace_back(M5_AT_NULL, 0);
}
stack_top -= (1 + argv.size()) * addrSize +
(1 + envp.size()) * addrSize +
((1 + argv.size()) * addrSize +
(1 + envp.size()) * addrSize +
addrSize + 2 * sizeof(IntType) * auxv.size()));
- memState->setStackMin(memState->getStackMin() & -2*addrSize);
+ memState->setStackMin(memState->getStackMin() & (-2 * addrSize));
Addr sp = memState->getStackMin();
const auto pushOntoStack =
- [this, &sp](const uint8_t* data, const size_t size) {
- initVirtMem.writeBlob(sp, data, size);
- sp += size;
+ [this, &sp](IntType data) {
+ initVirtMem.write(sp, data, GuestByteOrder);
+ sp += sizeof(data);
};
// Push argc and argv pointers onto stack
- IntType argc = htog((IntType)argv.size());
- DPRINTF(Stack, "Wrote argc %d to address %p\n",
- argv.size(), (void*)sp);
- pushOntoStack((uint8_t*)&argc, sizeof(IntType));
+ IntType argc = argv.size();
+ DPRINTF(Stack, "Wrote argc %d to address %#x\n", argc, sp);
+ pushOntoStack(argc);
+
for (const Addr& argPointer: argPointers) {
- DPRINTF(Stack, "Wrote argv pointer %p to address %p\n",
- (void*)argPointer, (void*)sp);
- pushOntoStack((uint8_t*)&argPointer, addrSize);
+ DPRINTF(Stack, "Wrote argv pointer %#x to address %#x\n",
+ argPointer, sp);
+ pushOntoStack(argPointer);
}
// Push env pointers onto stack
for (const Addr& envPointer: envPointers) {
- DPRINTF(Stack, "Wrote envp pointer %p to address %p\n",
- (void*)envPointer, (void*)sp);
- pushOntoStack((uint8_t*)&envPointer, addrSize);
+ DPRINTF(Stack, "Wrote envp pointer %#x to address %#x\n",
+ envPointer, sp);
+ pushOntoStack(envPointer);
}
// Push aux vector onto stack
{M5_AT_RANDOM, "M5_AT_RANDOM"},
{M5_AT_NULL, "M5_AT_NULL"}
};
- for (const AuxVector<IntType>& aux: auxv) {
- DPRINTF(Stack, "Wrote aux key %s to address %p\n",
- aux_keys[aux.getAuxType()], (void*)sp);
- pushOntoStack((uint8_t*)&aux.getAuxType(), sizeof(IntType));
- DPRINTF(Stack, "Wrote aux value %x to address %p\n",
- aux.getAuxVal(), (void*)sp);
- pushOntoStack((uint8_t*)&aux.getAuxVal(), sizeof(IntType));
+ for (const auto &aux: auxv) {
+ DPRINTF(Stack, "Wrote aux key %s to address %#x\n",
+ aux_keys[aux.type], sp);
+ pushOntoStack(aux.type);
+ DPRINTF(Stack, "Wrote aux value %x to address %#x\n", aux.val, sp);
+ pushOntoStack(aux.val);
}
ThreadContext *tc = system->getThreadContext(contextIds[0]);
{
int intSize = sizeof(IntType);
- typedef AuxVector<IntType> auxv_t;
-
- std::vector<auxv_t> auxv;
+ std::vector<AuxVector<IntType>> auxv;
string filename;
if (argv.size() < 1)
ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile);
if (elfObject) {
// Bits which describe the system hardware capabilities
- auxv.push_back(auxv_t(M5_AT_HWCAP, hwcap));
+ auxv.emplace_back(M5_AT_HWCAP, hwcap);
// The system page size
- auxv.push_back(auxv_t(M5_AT_PAGESZ, SparcISA::PageBytes));
+ auxv.emplace_back(M5_AT_PAGESZ, SparcISA::PageBytes);
// Defined to be 100 in the kernel source.
// Frequency at which times() increments
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 100));
- // For statically linked executables, this is the virtual address of the
- // program header tables if they appear in the executable image
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
+ auxv.emplace_back(M5_AT_CLKTCK, 100);
+ // For statically linked executables, this is the virtual address of
+ // the program header tables if they appear in the executable image
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
// This is the size of a program header entry from the elf file.
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
// This is the number of program headers from the original elf file.
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
// This is hardwired to 0 in the elf loading code in the kernel
- auxv.push_back(auxv_t(M5_AT_FLAGS, 0));
+ auxv.emplace_back(M5_AT_FLAGS, 0);
// The entry point to the program
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
// Different user and group IDs
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
// Whether to enable "secure mode" in the executable
- auxv.push_back(auxv_t(M5_AT_SECURE, 0));
+ auxv.emplace_back(M5_AT_SECURE, 0);
}
// Figure out how big the initial stack needs to be
initVirtMem.writeString(file_name_base, filename.c_str());
// Copy the aux stuff
- for (int x = 0; x < auxv.size(); x++) {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()), intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()), intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
// Write out the terminating zeroed auxilliary vector
- const IntType zero = 0;
- initVirtMem.writeBlob(auxv_array_base + intSize * 2 * auxv.size(),
- (uint8_t*)&zero, intSize);
- initVirtMem.writeBlob(auxv_array_base + intSize * (2 * auxv.size() + 1),
- (uint8_t*)&zero, intSize);
+ const AuxVector<IntType> zero(0, 0);
+ initVirtMem.write(auxv_array_end, zero);
+ auxv_array_end += sizeof(zero);
copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
{
int intSize = sizeof(IntType);
- typedef AuxVector<IntType> auxv_t;
- std::vector<auxv_t> auxv = extraAuxvs;
+ std::vector<AuxVector<IntType>> auxv = extraAuxvs;
string filename;
if (argv.size() < 1)
// Bits which describe the system hardware capabilities
// XXX Figure out what these should be
- auxv.push_back(auxv_t(M5_AT_HWCAP, features));
+ auxv.emplace_back(M5_AT_HWCAP, features);
// The system page size
- auxv.push_back(auxv_t(M5_AT_PAGESZ, X86ISA::PageBytes));
+ auxv.emplace_back(M5_AT_PAGESZ, X86ISA::PageBytes);
// Frequency at which times() increments
// Defined to be 100 in the kernel source.
- auxv.push_back(auxv_t(M5_AT_CLKTCK, 100));
+ auxv.emplace_back(M5_AT_CLKTCK, 100);
// This is the virtual address of the program header tables if they
// appear in the executable image.
- auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
+ auxv.emplace_back(M5_AT_PHDR, elfObject->programHeaderTable());
// This is the size of a program header entry from the elf file.
- auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
+ auxv.emplace_back(M5_AT_PHENT, elfObject->programHeaderSize());
// This is the number of program headers from the original elf file.
- auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
+ auxv.emplace_back(M5_AT_PHNUM, elfObject->programHeaderCount());
// This is the base address of the ELF interpreter; it should be
// zero for static executables or contain the base address for
// dynamic executables.
- auxv.push_back(auxv_t(M5_AT_BASE, getBias()));
+ auxv.emplace_back(M5_AT_BASE, getBias());
// XXX Figure out what this should be.
- auxv.push_back(auxv_t(M5_AT_FLAGS, 0));
+ auxv.emplace_back(M5_AT_FLAGS, 0);
// The entry point to the program
- auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
+ auxv.emplace_back(M5_AT_ENTRY, objFile->entryPoint());
// Different user and group IDs
- auxv.push_back(auxv_t(M5_AT_UID, uid()));
- auxv.push_back(auxv_t(M5_AT_EUID, euid()));
- auxv.push_back(auxv_t(M5_AT_GID, gid()));
- auxv.push_back(auxv_t(M5_AT_EGID, egid()));
+ auxv.emplace_back(M5_AT_UID, uid());
+ auxv.emplace_back(M5_AT_EUID, euid());
+ auxv.emplace_back(M5_AT_GID, gid());
+ auxv.emplace_back(M5_AT_EGID, egid());
// Whether to enable "secure mode" in the executable
- auxv.push_back(auxv_t(M5_AT_SECURE, 0));
+ auxv.emplace_back(M5_AT_SECURE, 0);
// The address of 16 "random" bytes.
- auxv.push_back(auxv_t(M5_AT_RANDOM, 0));
+ auxv.emplace_back(M5_AT_RANDOM, 0);
// The name of the program
- auxv.push_back(auxv_t(M5_AT_EXECFN, 0));
+ auxv.emplace_back(M5_AT_EXECFN, 0);
// The platform string
- auxv.push_back(auxv_t(M5_AT_PLATFORM, 0));
+ auxv.emplace_back(M5_AT_PLATFORM, 0);
}
// Figure out how big the initial stack needs to be
initVirtMem.writeString(file_name_base, filename.c_str());
// Fix up the aux vectors which point to data
- assert(auxv[auxv.size() - 3].getHostAuxType() == M5_AT_RANDOM);
- auxv[auxv.size() - 3].setAuxVal(aux_data_base);
- assert(auxv[auxv.size() - 2].getHostAuxType() == M5_AT_EXECFN);
- auxv[auxv.size() - 2].setAuxVal(argv_array_base);
- assert(auxv[auxv.size() - 1].getHostAuxType() == M5_AT_PLATFORM);
- auxv[auxv.size() - 1].setAuxVal(aux_data_base + numRandomBytes);
+ assert(auxv[auxv.size() - 3].type == M5_AT_RANDOM);
+ auxv[auxv.size() - 3].val = aux_data_base;
+ assert(auxv[auxv.size() - 2].type == M5_AT_EXECFN);
+ auxv[auxv.size() - 2].val = argv_array_base;
+ assert(auxv[auxv.size() - 1].type == M5_AT_PLATFORM);
+ auxv[auxv.size() - 1].val = aux_data_base + numRandomBytes;
// Copy the aux stuff
- for (int x = 0; x < auxv.size(); x++) {
- initVirtMem.writeBlob(auxv_array_base + x * 2 * intSize,
- (uint8_t*)&(auxv[x].getAuxType()),
- intSize);
- initVirtMem.writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
- (uint8_t*)&(auxv[x].getAuxVal()),
- intSize);
+ Addr auxv_array_end = auxv_array_base;
+ for (const auto &aux: auxv) {
+ initVirtMem.write(auxv_array_end, aux, GuestByteOrder);
+ auxv_array_end += sizeof(aux);
}
// Write out the terminating zeroed auxiliary vector
- const uint64_t zero = 0;
- initVirtMem.writeBlob(auxv_array_base + auxv.size() * 2 * intSize,
- (uint8_t*)&zero, intSize);
- initVirtMem.writeBlob(auxv_array_base + (auxv.size() * 2 + 1) * intSize,
- (uint8_t*)&zero, intSize);
+ const AuxVector<uint64_t> zero(0, 0);
+ initVirtMem.write(auxv_array_end, zero);
+ auxv_array_end += sizeof(zero);
initVirtMem.writeString(aux_data_base, platform.c_str());
X86_64Process::argsInit(int pageSize)
{
std::vector<AuxVector<uint64_t> > extraAuxvs;
- extraAuxvs.push_back(AuxVector<uint64_t>(M5_AT_SYSINFO_EHDR,
- vsyscallPage.base));
+ extraAuxvs.emplace_back(M5_AT_SYSINFO_EHDR, vsyscallPage.base);
X86Process::argsInit<uint64_t>(pageSize, extraAuxvs);
}
{
std::vector<AuxVector<uint32_t> > extraAuxvs;
//Tell the binary where the vsyscall part of the vsyscall page is.
- extraAuxvs.push_back(AuxVector<uint32_t>(M5_AT_SYSINFO,
- vsyscallPage.base + vsyscallPage.vsyscallOffset));
- extraAuxvs.push_back(AuxVector<uint32_t>(M5_AT_SYSINFO_EHDR,
- vsyscallPage.base));
+ extraAuxvs.emplace_back(M5_AT_SYSINFO,
+ vsyscallPage.base + vsyscallPage.vsyscallOffset);
+ extraAuxvs.emplace_back(M5_AT_SYSINFO_EHDR, vsyscallPage.base);
X86Process::argsInit<uint32_t>(pageSize, extraAuxvs);
}
if env['TARGET_ISA'] != 'null':
SimObject('InstTracer.py')
SimObject('Process.py')
- Source('aux_vector.cc')
Source('faults.cc')
Source('process.cc')
Source('fd_array.cc')
+++ /dev/null
-/*
- * Copyright (c) 2016 Advanced Micro Devices, Inc.
- * All rights reserved.
- *
- * For use for simulation and test purposes only
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its
- * contributors may be used to endorse or promote products derived from this
- * software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Brandon Potter
- */
-
-#include "sim/aux_vector.hh"
-
-#include <inttypes.h>
-
-#include "config/the_isa.hh"
-
-#if THE_ISA == ALPHA_ISA
-#include "arch/alpha/linux/process.hh"
-
-#elif THE_ISA == SPARC_ISA
-#include "arch/sparc/linux/process.hh"
-#include "arch/sparc/solaris/process.hh"
-
-#elif THE_ISA == MIPS_ISA
-#include "arch/mips/linux/process.hh"
-
-#elif THE_ISA == ARM_ISA
-#include "arch/arm/freebsd/process.hh"
-#include "arch/arm/linux/process.hh"
-
-#elif THE_ISA == X86_ISA
-#include "arch/x86/linux/process.hh"
-
-#elif THE_ISA == RISCV_ISA
-#include "arch/riscv/linux/process.hh"
-
-#elif THE_ISA == POWER_ISA
-#include "arch/power/linux/process.hh"
-
-#else
-#error "THE_ISA not set"
-#endif
-
-#include "arch/isa_traits.hh"
-#include "sim/byteswap.hh"
-
-template<class IntType>
-AuxVector<IntType>::AuxVector(IntType type, IntType val)
- : _auxType(TheISA::htog(type)), _auxVal(TheISA::htog(val)),
- _auxHostType(type), _auxHostVal(val)
-{ }
-
-template<class IntType>
-inline void
-AuxVector<IntType>::setAuxType(IntType type)
-{
- _auxType = TheISA::htog(type);
- _auxHostType = type;
-}
-
-template<class IntType>
-inline void
-AuxVector<IntType>::setAuxVal(IntType val)
-{
- _auxVal = TheISA::htog(val);
- _auxHostVal = val;
-}
-
-template class AuxVector<uint32_t>;
-template class AuxVector<uint64_t>;
{
public:
AuxVector() = default;
- AuxVector(IntType type, IntType val);
+ AuxVector(IntType _type, IntType _val) : type(_type), val(_val) {}
- IntType const& getAuxType() const { return _auxType; }
- IntType const& getAuxVal() const { return _auxVal; }
- IntType const& getHostAuxType() const { return _auxHostType; }
- IntType const& getHostAuxVal() const { return _auxHostVal; }
-
- void setAuxType(IntType type);
- void setAuxVal(IntType val);
-
- private:
- IntType _auxType = 0;
- IntType _auxVal = 0;
- IntType _auxHostType = 0;
- IntType _auxHostVal = 0;
+ IntType type = 0;
+ IntType val = 0;
};
+template<class IntType>
+inline AuxVector<IntType>
+swap_byte(AuxVector<IntType> av)
+{
+ av.type = swap_byte(av.type);
+ av.val = swap_byte(av.val);
+ return av;
+}
+
enum AuxiliaryVectorType {
M5_AT_NULL = 0, // End of vector.
M5_AT_IGNORE = 1, // Ignored.
projects / gem5.git / commitdiff