2003-10-08 08:13:01 +02:00
|
|
|
/*
|
arm: Add support for ARMv8 (AArch64 & AArch32)
Note: AArch64 and AArch32 interworking is not supported. If you use an AArch64
kernel you are restricted to AArch64 user-mode binaries. This will be addressed
in a later patch.
Note: Virtualization is only supported in AArch32 mode. This will also be fixed
in a later patch.
Contributors:
Giacomo Gabrielli (TrustZone, LPAE, system-level AArch64, AArch64 NEON, validation)
Thomas Grocutt (AArch32 Virtualization, AArch64 FP, validation)
Mbou Eyole (AArch64 NEON, validation)
Ali Saidi (AArch64 Linux support, code integration, validation)
Edmund Grimley-Evans (AArch64 FP)
William Wang (AArch64 Linux support)
Rene De Jong (AArch64 Linux support, performance opt.)
Matt Horsnell (AArch64 MP, validation)
Matt Evans (device models, code integration, validation)
Chris Adeniyi-Jones (AArch64 syscall-emulation)
Prakash Ramrakhyani (validation)
Dam Sunwoo (validation)
Chander Sudanthi (validation)
Stephan Diestelhorst (validation)
Andreas Hansson (code integration, performance opt.)
Eric Van Hensbergen (performance opt.)
Gabe Black
2014-01-24 22:29:34 +01:00
|
|
|
* Copyright (c) 2011-2013 ARM Limited
|
|
|
|
* All rights reserved
|
|
|
|
*
|
|
|
|
* The license below extends only to copyright in the software and shall
|
|
|
|
* not be construed as granting a license to any other intellectual
|
|
|
|
* property including but not limited to intellectual property relating
|
|
|
|
* to a hardware implementation of the functionality of the software
|
|
|
|
* licensed hereunder. You may use the software subject to the license
|
|
|
|
* terms below provided that you ensure that this notice is replicated
|
|
|
|
* unmodified and in its entirety in all distributions of the software,
|
|
|
|
* modified or unmodified, in source code or in binary form.
|
|
|
|
*
|
2005-06-05 11:16:00 +02:00
|
|
|
* Copyright (c) 2003-2005 The Regents of The University of Michigan
|
2003-10-08 08:13:01 +02:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* 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;
|
|
|
|
* neither the name of the copyright holders 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
|
|
|
|
* OWNER 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.
|
2006-06-01 01:26:56 +02:00
|
|
|
*
|
|
|
|
* Authors: Steve Reinhardt
|
|
|
|
* Ali Saidi
|
2003-10-08 08:13:01 +02:00
|
|
|
*/
|
|
|
|
|
2016-03-17 18:31:03 +01:00
|
|
|
#include "base/loader/elf_object.hh"
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
2008-10-10 19:15:00 +02:00
|
|
|
#include <cassert>
|
2003-10-08 08:13:01 +02:00
|
|
|
#include <string>
|
|
|
|
|
2011-04-15 19:44:06 +02:00
|
|
|
#include "base/bitfield.hh"
|
2016-03-17 18:31:03 +01:00
|
|
|
#include "base/loader/symtab.hh"
|
2007-05-27 03:15:22 +02:00
|
|
|
#include "base/misc.hh"
|
2010-09-10 23:58:04 +02:00
|
|
|
#include "base/trace.hh"
|
2011-04-15 19:44:32 +02:00
|
|
|
#include "debug/Loader.hh"
|
2011-04-15 19:44:06 +02:00
|
|
|
#include "gelf.h"
|
2016-03-17 18:31:03 +01:00
|
|
|
#include "sim/byteswap.hh"
|
2006-03-10 01:21:35 +01:00
|
|
|
|
2003-10-08 08:13:01 +02:00
|
|
|
ObjectFile *
|
2016-03-17 18:33:02 +01:00
|
|
|
ElfObject::tryFile(const std::string &fname, size_t len, uint8_t *data,
|
2016-03-17 18:31:03 +01:00
|
|
|
bool skip_interp_check)
|
2003-10-08 08:13:01 +02:00
|
|
|
{
|
2004-01-15 07:30:16 +01:00
|
|
|
// check that header matches library version
|
2005-06-04 03:47:30 +02:00
|
|
|
if (elf_version(EV_CURRENT) == EV_NONE)
|
|
|
|
panic("wrong elf version number!");
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// get a pointer to elf structure
|
|
|
|
// Check that we actually have a elf file
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf *elf = elf_memory((char*)data, len);
|
|
|
|
assert(elf);
|
|
|
|
|
|
|
|
GElf_Ehdr ehdr;
|
arm: Add support for ARMv8 (AArch64 & AArch32)
Note: AArch64 and AArch32 interworking is not supported. If you use an AArch64
kernel you are restricted to AArch64 user-mode binaries. This will be addressed
in a later patch.
Note: Virtualization is only supported in AArch32 mode. This will also be fixed
in a later patch.
Contributors:
Giacomo Gabrielli (TrustZone, LPAE, system-level AArch64, AArch64 NEON, validation)
Thomas Grocutt (AArch32 Virtualization, AArch64 FP, validation)
Mbou Eyole (AArch64 NEON, validation)
Ali Saidi (AArch64 Linux support, code integration, validation)
Edmund Grimley-Evans (AArch64 FP)
William Wang (AArch64 Linux support)
Rene De Jong (AArch64 Linux support, performance opt.)
Matt Horsnell (AArch64 MP, validation)
Matt Evans (device models, code integration, validation)
Chris Adeniyi-Jones (AArch64 syscall-emulation)
Prakash Ramrakhyani (validation)
Dam Sunwoo (validation)
Chander Sudanthi (validation)
Stephan Diestelhorst (validation)
Andreas Hansson (code integration, performance opt.)
Eric Van Hensbergen (performance opt.)
Gabe Black
2014-01-24 22:29:34 +01:00
|
|
|
if (gelf_getehdr(elf, &ehdr) == 0) {
|
2004-01-08 01:46:45 +01:00
|
|
|
DPRINTFR(Loader, "Not ELF\n");
|
|
|
|
elf_end(elf);
|
|
|
|
return NULL;
|
2016-03-17 18:33:02 +01:00
|
|
|
}
|
2006-03-04 09:09:23 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
// Detect the architecture
|
|
|
|
Arch arch = UnknownArch;
|
|
|
|
if (ehdr.e_machine == EM_SPARC64 ||
|
|
|
|
(ehdr.e_machine == EM_SPARC &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS64) ||
|
|
|
|
ehdr.e_machine == EM_SPARCV9) {
|
|
|
|
arch = SPARC64;
|
|
|
|
} else if (ehdr.e_machine == EM_SPARC32PLUS ||
|
|
|
|
(ehdr.e_machine == EM_SPARC &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS32)) {
|
|
|
|
arch = SPARC32;
|
|
|
|
} else if (ehdr.e_machine == EM_MIPS &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
|
|
|
|
arch = Mips;
|
|
|
|
if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB) {
|
|
|
|
fatal("The binary you're trying to load is compiled for big "
|
|
|
|
"endian MIPS. gem5\nonly supports little endian MIPS. "
|
|
|
|
"Please recompile your binary.\n");
|
2006-03-04 09:09:23 +01:00
|
|
|
}
|
2016-03-17 18:33:02 +01:00
|
|
|
} else if (ehdr.e_machine == EM_X86_64 &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
|
|
|
|
arch = X86_64;
|
|
|
|
} else if (ehdr.e_machine == EM_386 &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
|
|
|
|
arch = I386;
|
|
|
|
} else if (ehdr.e_machine == EM_ARM &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
|
|
|
|
arch = bits(ehdr.e_entry, 0) ? Thumb : Arm;
|
|
|
|
} else if (ehdr.e_machine == EM_AARCH64 &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
|
|
|
|
arch = Arm64;
|
arch: [Patch 1/5] Added RISC-V base instruction set RV64I
First of five patches adding RISC-V to GEM5. This patch introduces the
base 64-bit ISA (RV64I) in src/arch/riscv for use with syscall emulation.
The multiply, floating point, and atomic memory instructions will be added
in additional patches, as well as support for more detailed CPU models.
The loader is also modified to be able to parse RISC-V ELF files, and a
"Hello world\!" example for RISC-V is added to test-progs.
Patch 2 will implement the multiply extension, RV64M; patch 3 will implement
the floating point (single- and double-precision) extensions, RV64FD;
patch 4 will implement the atomic memory instructions, RV64A, and patch 5
will add support for timing, minor, and detailed CPU models that is missing
from the first four patches (such as handling locked memory).
[Removed several unused parameters and imports from RiscvInterrupts.py,
RiscvISA.py, and RiscvSystem.py.]
[Fixed copyright information in RISC-V files copied from elsewhere that had
ARM licenses attached.]
[Reorganized instruction definitions in decoder.isa so that they are sorted
by opcode in preparation for the addition of ISA extensions M, A, F, D.]
[Fixed formatting of several files, removed some variables and
instructions that were missed when moving them to other patches, fixed
RISC-V Foundation copyright attribution, and fixed history of files
copied from other architectures using hg copy.]
[Fixed indentation of switch cases in isa.cc.]
[Reorganized syscall descriptions in linux/process.cc to remove large
number of repeated unimplemented system calls and added implmementations
to functions that have received them since it process.cc was first
created.]
[Fixed spacing for some copyright attributions.]
[Replaced the rest of the file copies using hg copy.]
[Fixed style check errors and corrected unaligned memory accesses.]
[Fix some minor formatting mistakes.]
Signed-off by: Alec Roelke
Signed-off by: Jason Lowe-Power <jason@lowepower.com>
2016-11-30 23:10:28 +01:00
|
|
|
} else if (ehdr.e_machine == EM_RISCV) {
|
|
|
|
arch = Riscv;
|
2016-03-17 18:33:02 +01:00
|
|
|
} else if (ehdr.e_machine == EM_PPC &&
|
|
|
|
ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
|
|
|
|
arch = Power;
|
|
|
|
if (ehdr.e_ident[EI_DATA] != ELFDATA2MSB) {
|
|
|
|
fatal("The binary you're trying to load is compiled for "
|
|
|
|
"little endian Power.\ngem5 only supports big "
|
|
|
|
"endian Power. Please recompile your binary.\n");
|
|
|
|
}
|
|
|
|
} else if (ehdr.e_machine == EM_PPC64) {
|
|
|
|
fatal("The binary you're trying to load is compiled for 64-bit "
|
|
|
|
"Power. M5\n only supports 32-bit Power. Please "
|
|
|
|
"recompile your binary.\n");
|
|
|
|
} else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
|
|
|
|
// Since we don't know how to check for alpha right now, we'll
|
|
|
|
// just assume if it wasn't something else and it's 64 bit, that's
|
|
|
|
// what it must be.
|
|
|
|
arch = Alpha;
|
|
|
|
} else {
|
|
|
|
warn("Unknown architecture: %d\n", ehdr.e_machine);
|
|
|
|
arch = UnknownArch;
|
|
|
|
}
|
2006-03-04 09:09:23 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
// Detect the operating system
|
|
|
|
OpSys op_sys;
|
|
|
|
switch (ehdr.e_ident[EI_OSABI]) {
|
|
|
|
case ELFOSABI_LINUX:
|
|
|
|
op_sys = Linux;
|
|
|
|
break;
|
|
|
|
case ELFOSABI_SOLARIS:
|
|
|
|
op_sys = Solaris;
|
|
|
|
break;
|
|
|
|
case ELFOSABI_TRU64:
|
|
|
|
op_sys = Tru64;
|
|
|
|
break;
|
|
|
|
case ELFOSABI_ARM:
|
|
|
|
op_sys = LinuxArmOABI;
|
|
|
|
break;
|
|
|
|
case ELFOSABI_FREEBSD:
|
|
|
|
op_sys = FreeBSD;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
op_sys = UnknownOpSys;
|
|
|
|
}
|
2006-05-15 23:37:03 +02:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
// Take a look at the .note.ABI section.
|
|
|
|
// It can let us know what's what.
|
|
|
|
if (op_sys == UnknownOpSys) {
|
|
|
|
int sec_idx = 1;
|
2006-03-15 22:26:40 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
// Get the first section
|
|
|
|
Elf_Scn *section = elf_getscn(elf, sec_idx);
|
|
|
|
|
|
|
|
// While there are no more sections
|
|
|
|
while (section && op_sys == UnknownOpSys) {
|
|
|
|
GElf_Shdr shdr;
|
|
|
|
gelf_getshdr(section, &shdr);
|
|
|
|
|
|
|
|
char *e_str = elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name);
|
|
|
|
if (shdr.sh_type == SHT_NOTE &&
|
|
|
|
!strcmp(".note.ABI-tag", e_str)) {
|
|
|
|
// we have found a ABI note section
|
|
|
|
// Check the 5th 32bit word for OS 0 == linux, 1 == hurd,
|
|
|
|
// 2 == solaris, 3 == freebsd
|
|
|
|
Elf_Data *raw_data = elf_rawdata(section, NULL);
|
|
|
|
assert(raw_data && raw_data->d_buf);
|
|
|
|
|
|
|
|
uint32_t raw_abi = ((uint32_t*)raw_data->d_buf)[4];
|
|
|
|
bool is_le = ehdr.e_ident[EI_DATA] == ELFDATA2LSB;
|
|
|
|
uint32_t os_abi = is_le ? htole(raw_abi) : htobe(raw_abi);
|
|
|
|
|
|
|
|
switch (os_abi) {
|
|
|
|
case 0:
|
|
|
|
op_sys = Linux;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
fatal("gem5 does not support the HURD ABI.\n");
|
|
|
|
case 2:
|
|
|
|
op_sys = Solaris;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
op_sys = FreeBSD;
|
2006-08-12 02:27:22 +02:00
|
|
|
break;
|
|
|
|
}
|
2016-03-17 18:33:02 +01:00
|
|
|
} // if section found
|
2006-08-12 02:27:22 +02:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
if (!strcmp(".SUNW_version", e_str) ||
|
|
|
|
!strcmp(".stab.index", e_str))
|
|
|
|
op_sys = Solaris;
|
2016-03-17 18:31:03 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
section = elf_getscn(elf, ++sec_idx);
|
|
|
|
} // while sections
|
|
|
|
}
|
2016-03-17 18:31:03 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
ElfObject * result = new ElfObject(fname, len, data, arch, op_sys);
|
|
|
|
|
|
|
|
// The number of headers in the file
|
|
|
|
result->_programHeaderCount = ehdr.e_phnum;
|
|
|
|
// Record the size of each entry
|
|
|
|
result->_programHeaderSize = ehdr.e_phentsize;
|
|
|
|
result->_programHeaderTable = 0;
|
|
|
|
if (result->_programHeaderCount) { // If there is a program header table
|
|
|
|
// Figure out the virtual address of the header table in the
|
|
|
|
// final memory image. We use the program headers themselves
|
|
|
|
// to translate from a file offset to the address in the image.
|
|
|
|
GElf_Phdr phdr;
|
|
|
|
uint64_t e_phoff = ehdr.e_phoff;
|
|
|
|
|
|
|
|
for (int i = 0; i < result->_programHeaderCount; i++) {
|
|
|
|
gelf_getphdr(elf, i, &phdr);
|
|
|
|
// Check if we've found the segment with the headers in it
|
|
|
|
if (phdr.p_offset <= e_phoff &&
|
|
|
|
phdr.p_offset + phdr.p_filesz > e_phoff) {
|
|
|
|
result->_programHeaderTable =
|
|
|
|
phdr.p_paddr + (e_phoff - phdr.p_offset);
|
2016-03-17 18:31:03 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-03-17 18:33:02 +01:00
|
|
|
}
|
2016-03-17 18:31:03 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
if (!skip_interp_check) {
|
|
|
|
for (int i = 0; i < ehdr.e_phnum; i++) {
|
|
|
|
GElf_Phdr phdr;
|
|
|
|
M5_VAR_USED void *check_p = gelf_getphdr(elf, i, &phdr);
|
|
|
|
assert(check_p != nullptr);
|
|
|
|
|
|
|
|
if (phdr.p_type != PT_INTERP)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
char *interp_path = (char*)data + phdr.p_offset;
|
|
|
|
int fd = open(interp_path, O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
fatal("Unable to open dynamic executable's interpreter.\n");
|
|
|
|
|
|
|
|
struct stat sb;
|
|
|
|
M5_VAR_USED int check_i = fstat(fd, &sb);
|
|
|
|
assert(check_i == 0);
|
|
|
|
|
|
|
|
void *mm = mmap(nullptr, sb.st_size, PROT_READ,
|
|
|
|
MAP_PRIVATE, fd, 0);
|
|
|
|
assert(mm != MAP_FAILED);
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
uint8_t *interp_image = (uint8_t*)mm;
|
|
|
|
ObjectFile *obj = tryFile(interp_path, sb.st_size,
|
|
|
|
interp_image, true);
|
|
|
|
assert(obj != nullptr);
|
|
|
|
result->interpreter = dynamic_cast<ElfObject*>(obj);
|
|
|
|
assert(result->interpreter != nullptr);
|
|
|
|
break;
|
|
|
|
}
|
2003-10-08 08:13:01 +02:00
|
|
|
}
|
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
elf_end(elf);
|
|
|
|
return result;
|
|
|
|
}
|
2003-10-08 08:13:01 +02:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
ElfObject::ElfObject(const std::string &_filename, size_t _len,
|
|
|
|
uint8_t *_data, Arch _arch, OpSys _op_sys)
|
|
|
|
: ObjectFile(_filename, _len, _data, _arch, _op_sys),
|
2016-03-17 18:31:03 +01:00
|
|
|
_programHeaderTable(0), _programHeaderSize(0), _programHeaderCount(0),
|
|
|
|
interpreter(nullptr), ldBias(0), relocate(true),
|
|
|
|
ldMin(std::numeric_limits<Addr>::max()),
|
|
|
|
ldMax(std::numeric_limits<Addr>::min())
|
2003-10-08 08:13:01 +02:00
|
|
|
{
|
2004-01-15 07:30:16 +01:00
|
|
|
// check that header matches library version
|
2005-06-04 03:47:30 +02:00
|
|
|
if (elf_version(EV_CURRENT) == EV_NONE)
|
|
|
|
panic("wrong elf version number!");
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// get a pointer to elf structure
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf *elf = elf_memory((char*)fileData,len);
|
|
|
|
assert(elf);
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// Check that we actually have a elf file
|
2016-03-17 18:33:02 +01:00
|
|
|
GElf_Ehdr ehdr;
|
2004-01-15 07:30:16 +01:00
|
|
|
if (gelf_getehdr(elf, &ehdr) ==0) {
|
2004-01-08 01:46:45 +01:00
|
|
|
panic("Not ELF, shouldn't be here");
|
2003-10-08 08:13:01 +02:00
|
|
|
}
|
|
|
|
|
2004-01-08 01:46:45 +01:00
|
|
|
entry = ehdr.e_entry;
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// initialize segment sizes to 0 in case they're not present
|
|
|
|
text.size = data.size = bss.size = 0;
|
2012-09-07 21:20:52 +02:00
|
|
|
text.baseAddr = data.baseAddr = bss.baseAddr = 0;
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
int sec_idx = 1;
|
2007-09-26 05:03:51 +02:00
|
|
|
|
|
|
|
// The first address of some important sections.
|
2016-03-17 18:33:02 +01:00
|
|
|
Addr text_sec_start = 0;
|
|
|
|
Addr data_sec_start = 0;
|
|
|
|
Addr bss_sec_start = 0;
|
2007-09-26 05:03:51 +02:00
|
|
|
|
|
|
|
// Get the first section
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf_Scn *section = elf_getscn(elf, sec_idx);
|
2007-09-26 05:03:51 +02:00
|
|
|
|
|
|
|
// Find the beginning of the most interesting sections.
|
2016-03-17 18:33:02 +01:00
|
|
|
while (section) {
|
|
|
|
GElf_Shdr shdr;
|
2007-09-26 05:03:51 +02:00
|
|
|
gelf_getshdr(section, &shdr);
|
2016-03-17 18:33:02 +01:00
|
|
|
char *sec_name = elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name);
|
|
|
|
|
|
|
|
if (sec_name) {
|
|
|
|
if (!strcmp(".text", sec_name)) {
|
|
|
|
text_sec_start = shdr.sh_addr;
|
|
|
|
} else if (!strcmp(".data", sec_name)) {
|
|
|
|
data_sec_start = shdr.sh_addr;
|
|
|
|
} else if (!strcmp(".bss", sec_name)) {
|
|
|
|
bss_sec_start = shdr.sh_addr;
|
2011-06-13 08:52:21 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Elf_Error errorNum = (Elf_Error)elf_errno();
|
|
|
|
if (errorNum != ELF_E_NONE) {
|
|
|
|
const char *errorMessage = elf_errmsg(errorNum);
|
|
|
|
fatal("Error from libelf: %s.\n", errorMessage);
|
|
|
|
}
|
2007-09-26 05:03:51 +02:00
|
|
|
}
|
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
section = elf_getscn(elf, ++sec_idx);
|
2007-09-26 05:03:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Go through all the segments in the program, record them, and scrape
|
|
|
|
// out information about the text, data, and bss areas needed by other
|
|
|
|
// code.
|
2004-01-15 07:30:16 +01:00
|
|
|
for (int i = 0; i < ehdr.e_phnum; ++i) {
|
|
|
|
GElf_Phdr phdr;
|
|
|
|
if (gelf_getphdr(elf, i, &phdr) == 0) {
|
2007-09-26 05:03:51 +02:00
|
|
|
panic("gelf_getphdr failed for segment %d.", i);
|
2004-01-15 07:30:16 +01:00
|
|
|
}
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// for now we don't care about non-loadable segments
|
|
|
|
if (!(phdr.p_type & PT_LOAD))
|
|
|
|
continue;
|
|
|
|
|
2016-03-17 18:31:03 +01:00
|
|
|
ldMin = std::min(ldMin, phdr.p_vaddr);
|
|
|
|
ldMax = std::max(ldMax, phdr.p_vaddr + phdr.p_memsz);
|
|
|
|
|
2007-09-26 05:03:51 +02:00
|
|
|
// Check to see if this segment contains the bss section.
|
2016-03-17 18:33:02 +01:00
|
|
|
if (phdr.p_paddr <= bss_sec_start &&
|
|
|
|
phdr.p_paddr + phdr.p_memsz > bss_sec_start &&
|
|
|
|
phdr.p_memsz - phdr.p_filesz > 0) {
|
2007-10-09 22:12:04 +02:00
|
|
|
bss.baseAddr = phdr.p_paddr + phdr.p_filesz;
|
2007-09-26 05:03:51 +02:00
|
|
|
bss.size = phdr.p_memsz - phdr.p_filesz;
|
|
|
|
bss.fileImage = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check to see if this is the text or data segment
|
2016-03-17 18:33:02 +01:00
|
|
|
if (phdr.p_vaddr <= text_sec_start &&
|
|
|
|
phdr.p_vaddr + phdr.p_filesz > text_sec_start) {
|
2016-03-17 18:31:03 +01:00
|
|
|
|
|
|
|
// If this value is nonzero, we need to flip the relocate flag.
|
|
|
|
if (phdr.p_vaddr != 0)
|
|
|
|
relocate = false;
|
|
|
|
|
2007-10-09 22:12:04 +02:00
|
|
|
text.baseAddr = phdr.p_paddr;
|
2004-01-15 07:30:16 +01:00
|
|
|
text.size = phdr.p_filesz;
|
2006-03-02 16:31:48 +01:00
|
|
|
text.fileImage = fileData + phdr.p_offset;
|
2016-03-17 18:33:02 +01:00
|
|
|
} else if (phdr.p_vaddr <= data_sec_start &&
|
|
|
|
phdr.p_vaddr + phdr.p_filesz > data_sec_start) {
|
2007-10-09 22:12:04 +02:00
|
|
|
data.baseAddr = phdr.p_paddr;
|
2004-01-15 07:30:16 +01:00
|
|
|
data.size = phdr.p_filesz;
|
2006-03-02 16:31:48 +01:00
|
|
|
data.fileImage = fileData + phdr.p_offset;
|
2006-03-16 16:31:00 +01:00
|
|
|
} else {
|
2016-02-07 02:21:18 +01:00
|
|
|
// If it's none of the above but is loadable,
|
2008-12-05 18:09:29 +01:00
|
|
|
// load the filesize worth of data
|
2007-09-26 05:03:51 +02:00
|
|
|
Segment extra;
|
2007-10-09 22:12:04 +02:00
|
|
|
extra.baseAddr = phdr.p_paddr;
|
2007-09-26 05:03:51 +02:00
|
|
|
extra.size = phdr.p_filesz;
|
|
|
|
extra.fileImage = fileData + phdr.p_offset;
|
|
|
|
extraSegments.push_back(extra);
|
2004-01-15 07:30:16 +01:00
|
|
|
}
|
2004-01-08 01:46:45 +01:00
|
|
|
}
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// should have found at least one loadable segment
|
2016-07-11 17:30:35 +02:00
|
|
|
warn_if(text.size == 0,
|
2016-07-11 11:39:30 +02:00
|
|
|
"Empty .text segment in '%s'. ELF file corrupted?\n",
|
|
|
|
filename);
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
DPRINTFR(Loader, "text: 0x%x %d\ndata: 0x%x %d\nbss: 0x%x %d\n",
|
|
|
|
text.baseAddr, text.size, data.baseAddr, data.size,
|
|
|
|
bss.baseAddr, bss.size);
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
elf_end(elf);
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// We will actually read the sections when we need to load them
|
|
|
|
}
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2003-10-08 08:13:01 +02:00
|
|
|
|
|
|
|
bool
|
2016-03-17 18:34:27 +01:00
|
|
|
ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding, Addr mask,
|
|
|
|
Addr base, Addr offset)
|
2003-10-08 08:13:01 +02:00
|
|
|
{
|
2004-01-08 01:46:45 +01:00
|
|
|
if (!symtab)
|
|
|
|
return false;
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// check that header matches library version
|
2005-06-04 03:47:30 +02:00
|
|
|
if (elf_version(EV_CURRENT) == EV_NONE)
|
|
|
|
panic("wrong elf version number!");
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// get a pointer to elf structure
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf *elf = elf_memory((char*)fileData,len);
|
2004-01-08 01:46:45 +01:00
|
|
|
assert(elf != NULL);
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// Get the first section
|
2016-03-17 18:33:02 +01:00
|
|
|
int sec_idx = 1; // there is a 0 but it is nothing, go figure
|
|
|
|
Elf_Scn *section = elf_getscn(elf, sec_idx);
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// While there are no more sections
|
2016-03-17 18:33:02 +01:00
|
|
|
bool found = false;
|
2004-01-15 07:30:16 +01:00
|
|
|
while (section != NULL) {
|
2016-03-17 18:33:02 +01:00
|
|
|
GElf_Shdr shdr;
|
2004-01-08 01:46:45 +01:00
|
|
|
gelf_getshdr(section, &shdr);
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
if (shdr.sh_type == SHT_SYMTAB) {
|
2004-01-08 01:46:45 +01:00
|
|
|
found = true;
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf_Data *data = elf_getdata(section, NULL);
|
|
|
|
int count = shdr.sh_size / shdr.sh_entsize;
|
2004-01-08 01:46:45 +01:00
|
|
|
DPRINTF(Loader, "Found Symbol Table, %d symbols present\n", count);
|
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
// loop through all the symbols, only loading global ones
|
2016-03-17 18:33:02 +01:00
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
GElf_Sym sym;
|
|
|
|
gelf_getsym(data, i, &sym);
|
2004-02-22 02:31:08 +01:00
|
|
|
if (GELF_ST_BIND(sym.st_info) == binding) {
|
2010-08-23 18:18:40 +02:00
|
|
|
char *sym_name = elf_strptr(elf, shdr.sh_link, sym.st_name);
|
|
|
|
if (sym_name && sym_name[0] != '$') {
|
2016-03-17 18:34:27 +01:00
|
|
|
Addr value = sym.st_value - base + offset;
|
|
|
|
if (symtab->insert(value & mask, sym_name)) {
|
|
|
|
DPRINTF(Loader, "Symbol: %-40s value %#x\n",
|
|
|
|
sym_name, value);
|
|
|
|
}
|
2010-08-23 18:18:40 +02:00
|
|
|
}
|
2004-01-08 01:46:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-01-14 22:12:00 +01:00
|
|
|
++sec_idx;
|
|
|
|
section = elf_getscn(elf, sec_idx);
|
2004-01-08 01:46:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
elf_end(elf);
|
|
|
|
|
|
|
|
return found;
|
2003-10-08 08:13:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2016-03-17 18:34:27 +01:00
|
|
|
ElfObject::loadAllSymbols(SymbolTable *symtab, Addr base, Addr offset,
|
|
|
|
Addr addr_mask)
|
2003-10-08 08:13:01 +02:00
|
|
|
{
|
2016-03-17 18:34:27 +01:00
|
|
|
return (loadGlobalSymbols(symtab, base, offset, addr_mask) &&
|
|
|
|
loadLocalSymbols(symtab, base, offset, addr_mask) &&
|
|
|
|
loadWeakSymbols(symtab, base, offset, addr_mask));
|
2004-01-15 07:30:16 +01:00
|
|
|
}
|
2004-01-08 01:46:45 +01:00
|
|
|
|
2004-01-15 07:30:16 +01:00
|
|
|
bool
|
2016-03-17 18:34:27 +01:00
|
|
|
ElfObject::loadGlobalSymbols(SymbolTable *symtab, Addr base, Addr offset,
|
|
|
|
Addr addr_mask)
|
2004-01-15 07:30:16 +01:00
|
|
|
{
|
2016-03-17 18:34:27 +01:00
|
|
|
if (interpreter) {
|
|
|
|
interpreter->loadSomeSymbols(symtab, STB_GLOBAL, addr_mask,
|
|
|
|
base, offset);
|
|
|
|
}
|
|
|
|
return loadSomeSymbols(symtab, STB_GLOBAL, addr_mask, base, offset);
|
2003-10-08 08:13:01 +02:00
|
|
|
}
|
2007-01-22 22:14:06 +01:00
|
|
|
|
2013-04-17 23:07:19 +02:00
|
|
|
bool
|
2016-03-17 18:34:27 +01:00
|
|
|
ElfObject::loadLocalSymbols(SymbolTable *symtab, Addr base, Addr offset,
|
|
|
|
Addr addr_mask)
|
2013-04-17 23:07:19 +02:00
|
|
|
{
|
2016-03-17 18:34:27 +01:00
|
|
|
if (interpreter) {
|
|
|
|
interpreter->loadSomeSymbols(symtab, STB_LOCAL, addr_mask,
|
|
|
|
base, offset);
|
|
|
|
}
|
|
|
|
return loadSomeSymbols(symtab, STB_LOCAL, addr_mask, base, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ElfObject::loadWeakSymbols(SymbolTable *symtab, Addr base, Addr offset,
|
|
|
|
Addr addr_mask)
|
|
|
|
{
|
|
|
|
if (interpreter) {
|
|
|
|
interpreter->loadSomeSymbols(symtab, STB_WEAK, addr_mask,
|
|
|
|
base, offset);
|
|
|
|
}
|
|
|
|
return loadSomeSymbols(symtab, STB_WEAK, addr_mask, base, offset);
|
2013-04-17 23:07:19 +02:00
|
|
|
}
|
|
|
|
|
2007-09-26 05:03:51 +02:00
|
|
|
bool
|
2016-03-17 18:33:02 +01:00
|
|
|
ElfObject::loadSections(PortProxy& mem_proxy, Addr addr_mask, Addr offset)
|
2007-09-26 05:03:51 +02:00
|
|
|
{
|
2016-03-17 18:33:02 +01:00
|
|
|
if (!ObjectFile::loadSections(mem_proxy, addr_mask, offset))
|
2007-09-26 05:03:51 +02:00
|
|
|
return false;
|
|
|
|
|
2016-03-17 18:33:02 +01:00
|
|
|
for (auto seg : extraSegments) {
|
|
|
|
if (!loadSection(&seg, mem_proxy, addr_mask, offset)) {
|
2007-09-26 05:03:51 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2016-03-17 18:31:03 +01:00
|
|
|
|
|
|
|
if (interpreter)
|
2016-03-17 18:33:02 +01:00
|
|
|
interpreter->loadSections(mem_proxy, addr_mask, offset);
|
2016-03-17 18:31:03 +01:00
|
|
|
|
2007-09-26 05:03:51 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-09-11 06:01:24 +02:00
|
|
|
void
|
|
|
|
ElfObject::getSections()
|
2007-01-22 22:14:06 +01:00
|
|
|
{
|
2007-09-11 06:01:24 +02:00
|
|
|
assert(!sectionNames.size());
|
|
|
|
|
2007-01-22 22:14:06 +01:00
|
|
|
// check that header matches library version
|
|
|
|
if (elf_version(EV_CURRENT) == EV_NONE)
|
|
|
|
panic("wrong elf version number!");
|
|
|
|
|
|
|
|
// get a pointer to elf structure
|
2016-03-17 18:33:02 +01:00
|
|
|
Elf *elf = elf_memory((char*)fileData,len);
|
2007-01-22 22:14:06 +01:00
|
|
|
assert(elf != NULL);
|
|
|
|
|
|
|
|
// Check that we actually have a elf file
|
2016-03-17 18:33:02 +01:00
|
|
|
GElf_Ehdr ehdr;
|
2007-01-22 22:14:06 +01:00
|
|
|
if (gelf_getehdr(elf, &ehdr) ==0) {
|
|
|
|
panic("Not ELF, shouldn't be here");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the first section
|
2016-03-17 18:33:02 +01:00
|
|
|
int sec_idx = 1; // there is a 0 but it is nothing, go figure
|
|
|
|
Elf_Scn *section = elf_getscn(elf, sec_idx);
|
2007-01-22 22:14:06 +01:00
|
|
|
|
|
|
|
// While there are no more sections
|
2016-03-17 18:33:02 +01:00
|
|
|
while (section) {
|
|
|
|
GElf_Shdr shdr;
|
2007-01-22 22:14:06 +01:00
|
|
|
gelf_getshdr(section, &shdr);
|
2007-09-11 06:01:24 +02:00
|
|
|
sectionNames.insert(elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name));
|
2007-01-22 22:14:06 +01:00
|
|
|
section = elf_getscn(elf, ++sec_idx);
|
|
|
|
} // while sections
|
2007-09-11 06:01:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2016-03-17 18:33:02 +01:00
|
|
|
ElfObject::sectionExists(std::string sec)
|
2007-09-11 06:01:24 +02:00
|
|
|
{
|
|
|
|
if (!sectionNames.size())
|
|
|
|
getSections();
|
2016-03-17 18:33:02 +01:00
|
|
|
|
2007-09-11 06:01:24 +02:00
|
|
|
return sectionNames.find(sec) != sectionNames.end();
|
2007-01-22 22:14:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-03-17 18:31:03 +01:00
|
|
|
void
|
|
|
|
ElfObject::updateBias(Addr bias_addr)
|
|
|
|
{
|
|
|
|
// Record the bias.
|
|
|
|
ldBias = bias_addr;
|
|
|
|
|
|
|
|
// Patch the entry point with bias_addr.
|
|
|
|
entry += bias_addr;
|
|
|
|
|
|
|
|
// Patch segments with the bias_addr.
|
|
|
|
text.baseAddr += bias_addr;
|
|
|
|
data.baseAddr += bias_addr;
|
|
|
|
bss.baseAddr += bias_addr;
|
|
|
|
for (auto &segment : extraSegments)
|
|
|
|
segment.baseAddr += bias_addr;
|
|
|
|
}
|