imi415
/
openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

target/image: allow loading of 64-bit ELF files 

Change-Id: I9b88edacf5ffcc3c1caeab8c426693de0d92a695
Signed-off-by: Florian Meister <florian.meister@advantest.com>
Signed-off-by: Christian Hoff <christian.hoff@advantest.com>
Reviewed-on: http://openocd.zylin.com/5204
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-by: Ooi, Cinly <cinly.ooi@intel.com>
Reviewed-by: Tomas Vanek <vanekt@fbl.cz>
This commit is contained in:
Florian Meister 2019-06-05 10:19:52 +02:00 committed by Antonio Borneo
parent 11d918d9c1
commit 9206bd243b
4 changed files with 351 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
configure.ac
View File

@ -49,6 +49,9 @@ AC_SEARCH_LIBS([openpty], [util])
AC_CHECK_HEADERS([sys/socket.h])
AC_CHECK_HEADERS([elf.h])
AC_EGREP_HEADER(Elf64_Ehdr, [elf.h], [
AC_DEFINE([HAVE_ELF64], [1], [Define to 1 if the system has the type `Elf64_Ehdr'.])
])
AC_CHECK_HEADERS([dirent.h])
AC_CHECK_HEADERS([fcntl.h])
AC_CHECK_HEADERS([malloc.h])

42
src/helper/replacements.h
View File

@ -246,8 +246,10 @@ typedef uint32_t Elf32_Word;
typedef uint32_t Elf32_Size;
typedef Elf32_Off Elf32_Hashelt;
#define EI_NIDENT 16
typedef struct {
unsigned char e_ident[16]; /* Magic number and other info */
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf32_Half e_type; /* Object file type */
Elf32_Half e_machine; /* Architecture */
Elf32_Word e_version; /* Object file version */
@ -289,6 +291,44 @@ typedef struct {
#endif /* HAVE_ELF_H */
#ifndef HAVE_ELF64
typedef uint64_t Elf64_Addr;
typedef uint16_t Elf64_Half;
typedef uint64_t Elf64_Off;
typedef uint32_t Elf64_Word;
typedef uint64_t Elf64_Xword;
typedef struct {
unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
Elf64_Half e_type; /* Object file type */
Elf64_Half e_machine; /* Architecture */
Elf64_Word e_version; /* Object file version */
Elf64_Addr e_entry; /* Entry point virtual address */
Elf64_Off e_phoff; /* Program header table file offset */
Elf64_Off e_shoff; /* Section header table file offset */
Elf64_Word e_flags; /* Processor-specific flags */
Elf64_Half e_ehsize; /* ELF header size in bytes */
Elf64_Half e_phentsize; /* Program header table entry size */
Elf64_Half e_phnum; /* Program header table entry count */
Elf64_Half e_shentsize; /* Section header table entry size */
Elf64_Half e_shnum; /* Section header table entry count */
Elf64_Half e_shstrndx; /* Section header string table index */
} Elf64_Ehdr;
typedef struct {
Elf64_Word p_type; /* Segment type */
Elf64_Word p_flags; /* Segment flags */
Elf64_Off p_offset; /* Segment file offset */
Elf64_Addr p_vaddr; /* Segment virtual address */
Elf64_Addr p_paddr; /* Segment physical address */
Elf64_Xword p_filesz; /* Segment size in file */
Elf64_Xword p_memsz; /* Segment size in memory */
Elf64_Xword p_align; /* Segment alignment */
} Elf64_Phdr;
#endif /* HAVE_ELF64 */
#if defined HAVE_LIBUSB1 && !defined HAVE_LIBUSB_ERROR_NAME
const char *libusb_error_name(int error_code);
#endif /* defined HAVE_LIBUSB1 && !defined HAVE_LIBUSB_ERROR_NAME */

349
src/target/image.c
View File

@ -11,6 +11,9 @@
* Copyright (C) 2009 by Franck Hereson *
* franck.hereson@secad.fr *
* *
* Copyright (C) 2018 by Advantest *
* florian.meister@advantest.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
@ -42,6 +45,10 @@
((elf->endianness == ELFDATA2LSB) ? \
le_to_h_u32((uint8_t *)&field) : be_to_h_u32((uint8_t *)&field))
#define field64(elf, field) \
((elf->endianness == ELFDATA2LSB) ? \
le_to_h_u64((uint8_t *)&field) : be_to_h_u64((uint8_t *)&field))
static int autodetect_image_type(struct image *image, const char *url)
{
int retval;
@ -49,7 +56,7 @@ static int autodetect_image_type(struct image *image, const char *url)
size_t read_bytes;
uint8_t buffer[9];
/* read the first 4 bytes of image */
/* read the first 9 bytes of image */
retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY);
if (retval != ERROR_OK)
return retval;
@ -350,22 +357,29 @@ static int image_ihex_buffer_complete(struct image *image)
return retval;
}
static int image_elf_read_headers(struct image *image)
static int image_elf32_read_headers(struct image *image)
{
struct image_elf *elf = image->type_private;
size_t read_bytes;
uint32_t i, j;
int retval;
uint32_t nload, load_to_vaddr = 0;
uint32_t nload;
bool load_to_vaddr = false;
elf->header = malloc(sizeof(Elf32_Ehdr));
retval = fileio_seek(elf->fileio, 0);
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF file header, read failed");
return retval;
}
if (elf->header == NULL) {
LOG_ERROR("insufficient memory to perform operation ");
elf->header32 = malloc(sizeof(Elf32_Ehdr));
if (elf->header32 == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
retval = fileio_read(elf->fileio, sizeof(Elf32_Ehdr), (uint8_t *)elf->header, &read_bytes);
retval = fileio_read(elf->fileio, sizeof(Elf32_Ehdr), (uint8_t *)elf->header32, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF file header, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
@ -375,42 +389,26 @@ static int image_elf_read_headers(struct image *image)
return ERROR_FILEIO_OPERATION_FAILED;
}
if (strncmp((char *)elf->header->e_ident, ELFMAG, SELFMAG) != 0) {
LOG_ERROR("invalid ELF file, bad magic number");
return ERROR_IMAGE_FORMAT_ERROR;
}
if (elf->header->e_ident[EI_CLASS] != ELFCLASS32) {
LOG_ERROR("invalid ELF file, only 32bits files are supported");
return ERROR_IMAGE_FORMAT_ERROR;
}
elf->endianness = elf->header->e_ident[EI_DATA];
if ((elf->endianness != ELFDATA2LSB)
&& (elf->endianness != ELFDATA2MSB)) {
LOG_ERROR("invalid ELF file, unknown endianness setting");
return ERROR_IMAGE_FORMAT_ERROR;
}
elf->segment_count = field16(elf, elf->header->e_phnum);
elf->segment_count = field16(elf, elf->header32->e_phnum);
if (elf->segment_count == 0) {
LOG_ERROR("invalid ELF file, no program headers");
return ERROR_IMAGE_FORMAT_ERROR;
}
retval = fileio_seek(elf->fileio, field32(elf, elf->header->e_phoff));
retval = fileio_seek(elf->fileio, field32(elf, elf->header32->e_phoff));
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF program header table, read failed");
return retval;
}
elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
if (elf->segments == NULL) {
LOG_ERROR("insufficient memory to perform operation ");
elf->segments32 = malloc(elf->segment_count*sizeof(Elf32_Phdr));
if (elf->segments32 == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
retval = fileio_read(elf->fileio, elf->segment_count*sizeof(Elf32_Phdr),
(uint8_t *)elf->segments, &read_bytes);
(uint8_t *)elf->segments32, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment headers, read failed");
return retval;
@ -424,8 +422,8 @@ static int image_elf_read_headers(struct image *image)
image->num_sections = 0;
for (i = 0; i < elf->segment_count; i++)
if ((field32(elf,
elf->segments[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments[i].p_filesz) != 0))
elf->segments32[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments32[i].p_filesz) != 0))
image->num_sections++;
assert(image->num_sections > 0);
@ -441,44 +439,217 @@ static int image_elf_read_headers(struct image *image)
* when obtaining lma - look at elf.c of BDF)
*/
for (nload = 0, i = 0; i < elf->segment_count; i++)
if (elf->segments[i].p_paddr != 0)
if (elf->segments32[i].p_paddr != 0)
break;
else if ((field32(elf,
elf->segments[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments[i].p_memsz) != 0))
elf->segments32[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments32[i].p_memsz) != 0))
++nload;
if (i >= elf->segment_count && nload > 1)
load_to_vaddr = 1;
load_to_vaddr = true;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(struct imagesection));
if (image->sections == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
for (i = 0, j = 0; i < elf->segment_count; i++) {
if ((field32(elf,
elf->segments[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments[i].p_filesz) != 0)) {
image->sections[j].size = field32(elf, elf->segments[i].p_filesz);
elf->segments32[i].p_type) == PT_LOAD) &&
(field32(elf, elf->segments32[i].p_filesz) != 0)) {
image->sections[j].size = field32(elf, elf->segments32[i].p_filesz);
if (load_to_vaddr)
image->sections[j].base_address = field32(elf,
elf->segments[i].p_vaddr);
elf->segments32[i].p_vaddr);
else
image->sections[j].base_address = field32(elf,
elf->segments[i].p_paddr);
image->sections[j].private = &elf->segments[i];
image->sections[j].flags = field32(elf, elf->segments[i].p_flags);
elf->segments32[i].p_paddr);
image->sections[j].private = &elf->segments32[i];
image->sections[j].flags = field32(elf, elf->segments32[i].p_flags);
j++;
}
}
image->start_address_set = true;
image->start_address = field32(elf, elf->header->e_entry);
image->start_address = field32(elf, elf->header32->e_entry);
return ERROR_OK;
}
static int image_elf_read_section(struct image *image,
static int image_elf64_read_headers(struct image *image)
{
struct image_elf *elf = image->type_private;
size_t read_bytes;
uint32_t i, j;
int retval;
uint32_t nload;
bool load_to_vaddr = false;
retval = fileio_seek(elf->fileio, 0);
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF file header, read failed");
return retval;
}
elf->header64 = malloc(sizeof(Elf64_Ehdr));
if (elf->header64 == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
retval = fileio_read(elf->fileio, sizeof(Elf64_Ehdr), (uint8_t *)elf->header64, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF file header, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
}
if (read_bytes != sizeof(Elf64_Ehdr)) {
LOG_ERROR("cannot read ELF file header, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
}
elf->segment_count = field16(elf, elf->header64->e_phnum);
if (elf->segment_count == 0) {
LOG_ERROR("invalid ELF file, no program headers");
return ERROR_IMAGE_FORMAT_ERROR;
}
retval = fileio_seek(elf->fileio, field64(elf, elf->header64->e_phoff));
if (retval != ERROR_OK) {
LOG_ERROR("cannot seek to ELF program header table, read failed");
return retval;
}
elf->segments64 = malloc(elf->segment_count*sizeof(Elf64_Phdr));
if (elf->segments64 == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
retval = fileio_read(elf->fileio, elf->segment_count*sizeof(Elf64_Phdr),
(uint8_t *)elf->segments64, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment headers, read failed");
return retval;
}
if (read_bytes != elf->segment_count*sizeof(Elf64_Phdr)) {
LOG_ERROR("cannot read ELF segment headers, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
}
/* count useful segments (loadable), ignore BSS section */
image->num_sections = 0;
for (i = 0; i < elf->segment_count; i++)
if ((field32(elf,
elf->segments64[i].p_type) == PT_LOAD) &&
(field64(elf, elf->segments64[i].p_filesz) != 0))
image->num_sections++;
assert(image->num_sections > 0);
/**
* some ELF linkers produce binaries with *all* the program header
* p_paddr fields zero (there can be however one loadable segment
* that has valid physical address 0x0).
* If we have such a binary with more than
* one PT_LOAD header, then use p_vaddr instead of p_paddr
* (ARM ELF standard demands p_paddr = 0 anyway, and BFD
* library uses this approach to workaround zero-initialized p_paddrs
* when obtaining lma - look at elf.c of BDF)
*/
for (nload = 0, i = 0; i < elf->segment_count; i++)
if (elf->segments64[i].p_paddr != 0)
break;
else if ((field32(elf,
elf->segments64[i].p_type) == PT_LOAD) &&
(field64(elf, elf->segments64[i].p_memsz) != 0))
++nload;
if (i >= elf->segment_count && nload > 1)
load_to_vaddr = true;
/* alloc and fill sections array with loadable segments */
image->sections = malloc(image->num_sections * sizeof(struct imagesection));
if (image->sections == NULL) {
LOG_ERROR("insufficient memory to perform operation");
return ERROR_FILEIO_OPERATION_FAILED;
}
for (i = 0, j = 0; i < elf->segment_count; i++) {
if ((field32(elf,
elf->segments64[i].p_type) == PT_LOAD) &&
(field64(elf, elf->segments64[i].p_filesz) != 0)) {
image->sections[j].size = field64(elf, elf->segments64[i].p_filesz);
if (load_to_vaddr)
image->sections[j].base_address = field64(elf,
elf->segments64[i].p_vaddr);
else
image->sections[j].base_address = field64(elf,
elf->segments64[i].p_paddr);
image->sections[j].private = &elf->segments64[i];
image->sections[j].flags = field32(elf, elf->segments64[i].p_flags);
j++;
}
}
image->start_address_set = true;
image->start_address = field64(elf, elf->header64->e_entry);
return ERROR_OK;
}
static int image_elf_read_headers(struct image *image)
{
struct image_elf *elf = image->type_private;
size_t read_bytes;
unsigned char e_ident[EI_NIDENT];
int retval;
retval = fileio_read(elf->fileio, EI_NIDENT, e_ident, &read_bytes);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF file header, read failed");
return ERROR_FILEIO_OPERATION_FAILED;
}
if (read_bytes != EI_NIDENT) {
LOG_ERROR("cannot read ELF file header, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
}
if (strncmp((char *)e_ident, ELFMAG, SELFMAG) != 0) {
LOG_ERROR("invalid ELF file, bad magic number");
return ERROR_IMAGE_FORMAT_ERROR;
}
elf->endianness = e_ident[EI_DATA];
if ((elf->endianness != ELFDATA2LSB)
&& (elf->endianness != ELFDATA2MSB)) {
LOG_ERROR("invalid ELF file, unknown endianness setting");
return ERROR_IMAGE_FORMAT_ERROR;
}
switch (e_ident[EI_CLASS]) {
case ELFCLASS32:
LOG_DEBUG("ELF32 image detected.");
elf->is_64_bit = false;
return image_elf32_read_headers(image);
case ELFCLASS64:
LOG_DEBUG("ELF64 image detected.");
elf->is_64_bit = true;
return image_elf64_read_headers(image);
default:
LOG_ERROR("invalid ELF file, only 32/64 bit ELF files are supported");
return ERROR_IMAGE_FORMAT_ERROR;
}
}
static int image_elf32_read_section(struct image *image,
int section,
uint32_t offset,
target_addr_t offset,
uint32_t size,
uint8_t *buffer,
size_t *size_read)
@ -490,13 +661,13 @@ static int image_elf_read_section(struct image *image,
*size_read = 0;
LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz = 0x%" PRIx32 ")", section, offset, size);
LOG_DEBUG("load segment %d at 0x%" TARGET_PRIxADDR " (sz = 0x%" PRIx32 ")", section, offset, size);
/* read initialized data in current segment if any */
if (offset < field32(elf, segment->p_filesz)) {
/* maximal size present in file for the current segment */
read_size = MIN(size, field32(elf, segment->p_filesz) - offset);
LOG_DEBUG("read elf: size = 0x%zx at 0x%" PRIx32 "", read_size,
LOG_DEBUG("read elf: size = 0x%zx at 0x%" TARGET_PRIxADDR "", read_size,
field32(elf, segment->p_offset) + offset);
/* read initialized area of the segment */
retval = fileio_seek(elf->fileio, field32(elf, segment->p_offset) + offset);
@ -519,6 +690,64 @@ static int image_elf_read_section(struct image *image,
return ERROR_OK;
}
static int image_elf64_read_section(struct image *image,
int section,
target_addr_t offset,
uint32_t size,
uint8_t *buffer,
size_t *size_read)
{
struct image_elf *elf = image->type_private;
Elf64_Phdr *segment = (Elf64_Phdr *)image->sections[section].private;
size_t read_size, really_read;
int retval;
*size_read = 0;
LOG_DEBUG("load segment %d at 0x%" TARGET_PRIxADDR " (sz = 0x%" PRIx32 ")", section, offset, size);
/* read initialized data in current segment if any */
if (offset < field64(elf, segment->p_filesz)) {
/* maximal size present in file for the current segment */
read_size = MIN(size, field64(elf, segment->p_filesz) - offset);
LOG_DEBUG("read elf: size = 0x%zx at 0x%" TARGET_PRIxADDR "", read_size,
field64(elf, segment->p_offset) + offset);
/* read initialized area of the segment */
retval = fileio_seek(elf->fileio, field64(elf, segment->p_offset) + offset);
if (retval != ERROR_OK) {
LOG_ERROR("cannot find ELF segment content, seek failed");
return retval;
}
retval = fileio_read(elf->fileio, read_size, buffer, &really_read);
if (retval != ERROR_OK) {
LOG_ERROR("cannot read ELF segment content, read failed");
return retval;
}
size -= read_size;
*size_read += read_size;
/* need more data ? */
if (!size)
return ERROR_OK;
}
return ERROR_OK;
}
static int image_elf_read_section(struct image *image,
int section,
target_addr_t offset,
uint32_t size,
uint8_t *buffer,
size_t *size_read)
{
struct image_elf *elf = image->type_private;
if (elf->is_64_bit)
return image_elf64_read_section(image, section, offset, size, buffer, size_read);
else
return image_elf32_read_section(image, section, offset, size, buffer, size_read);
}
static int image_mot_buffer_complete_inner(struct image *image,
char *lpszLine,
struct imagesection *section)
@ -840,7 +1069,7 @@ int image_open(struct image *image, const char *url, const char *type_string)
int image_read_section(struct image *image,
int section,
uint32_t offset,
target_addr_t offset,
uint32_t size,
uint8_t *buffer,
size_t *size_read)
@ -850,7 +1079,7 @@ int image_read_section(struct image *image,
/* don't read past the end of a section */
if (offset + size > image->sections[section].size) {
LOG_DEBUG(
"read past end of section: 0x%8.8" PRIx32 " + 0x%8.8" PRIx32 " > 0x%8.8" PRIx32 "",
"read past end of section: 0x%8.8" TARGET_PRIxADDR " + 0x%8.8" PRIx32 " > 0x%8.8" PRIx32 "",
offset,
size,
image->sections[section].size);
@ -878,9 +1107,9 @@ int image_read_section(struct image *image,
*size_read = size;
return ERROR_OK;
} else if (image->type == IMAGE_ELF)
} else if (image->type == IMAGE_ELF) {
return image_elf_read_section(image, section, offset, size, buffer, size_read);
else if (image->type == IMAGE_MEMORY) {
} else if (image->type == IMAGE_MEMORY) {
struct image_memory *image_memory = image->type_private;
uint32_t address = image->sections[section].base_address + offset;
@ -933,7 +1162,7 @@ int image_read_section(struct image *image,
return ERROR_OK;
}
int image_add_section(struct image *image, uint32_t base, uint32_t size, int flags, uint8_t const *data)
int image_add_section(struct image *image, target_addr_t base, uint32_t size, int flags, uint8_t const *data)
{
struct imagesection *section;
@ -988,11 +1217,19 @@ void image_close(struct image *image)
fileio_close(image_elf->fileio);
free(image_elf->header);
image_elf->header = NULL;
if (image_elf->is_64_bit) {
free(image_elf->header64);
image_elf->header64 = NULL;
free(image_elf->segments);
image_elf->segments = NULL;
free(image_elf->segments64);
image_elf->segments64 = NULL;
} else {
free(image_elf->header32);
image_elf->header32 = NULL;
free(image_elf->segments32);
image_elf->segments32 = NULL;
}
} else if (image->type == IMAGE_MEMORY) {
struct image_memory *image_memory = image->type_private;

18
src/target/image.h
View File

@ -8,6 +8,9 @@
* Copyright (C) 2008 by Spencer Oliver *
* spen@spen-soft.co.uk *
* *
* Copyright (C) 2018 by Advantest *
* florian.meister@advantest.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
@ -80,8 +83,15 @@ struct image_memory {
struct image_elf {
struct fileio *fileio;
Elf32_Ehdr *header;
Elf32_Phdr *segments;
bool is_64_bit;
union {
Elf32_Ehdr *header32;
Elf64_Ehdr *header64;
};
union {
Elf32_Phdr *segments32;
Elf64_Phdr *segments64;
};
uint32_t segment_count;
uint8_t endianness;
};
@ -92,11 +102,11 @@ struct image_mot {
};
int image_open(struct image *image, const char *url, const char *type_string);
int image_read_section(struct image *image, int section, uint32_t offset,
int image_read_section(struct image *image, int section, target_addr_t offset,
uint32_t size, uint8_t *buffer, size_t *size_read);
void image_close(struct image *image);
int image_add_section(struct image *image, uint32_t base, uint32_t size,
int image_add_section(struct image *image, target_addr_t base, uint32_t size,
int flags, uint8_t const *data);
int image_calculate_checksum(const uint8_t *buffer, uint32_t nbytes,