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>

4 files changed, 349 insertions, 59 deletions

diff --git a/configure.ac b/configure.ac
index 5c7dab5..979bb16 100644
--- a/configure.ac
+++ b/configure.ac
@@ -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])
diff --git a/src/helper/replacements.h b/src/helper/replacements.h
index ac50095..fff2dde 100644
--- a/src/helper/replacements.h
+++ b/src/helper/replacements.h
@@ -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 */
diff --git a/src/target/image.c b/src/target/image.c
index e63cd0f..9608375 100644
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -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;
+
+	retval = fileio_seek(elf->fileio, 0);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("cannot seek to ELF file header, read failed");
+		return retval;
+	}
 
-	elf->header = malloc(sizeof(Elf32_Ehdr));
+	elf->header32 = malloc(sizeof(Elf32_Ehdr));
 
-	if (elf->header == NULL) {
-		LOG_ERROR("insufficient memory to perform operation ");
+	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,47 +389,153 @@ 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");
+	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;
 	}
-	if (elf->header->e_ident[EI_CLASS] != ELFCLASS32) {
-		LOG_ERROR("invalid ELF file, only 32bits files are supported");
-		return ERROR_IMAGE_FORMAT_ERROR;
+
+	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->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->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->segments32, &read_bytes);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("cannot read ELF segment headers, read failed");
+		return retval;
+	}
+	if (read_bytes != elf->segment_count*sizeof(Elf32_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->segments32[i].p_type) == PT_LOAD) &&
+			(field32(elf, elf->segments32[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->segments32[i].p_paddr != 0)
+			break;
+		else if ((field32(elf,
+			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 = 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->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->segments32[i].p_vaddr);
+			else
+				image->sections[j].base_address = field32(elf,
+						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->header32->e_entry);
+
+	return ERROR_OK;
+}
+
+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->header->e_phnum);
+	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, field32(elf, elf->header->e_phoff));
+	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->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
-	if (elf->segments == NULL) {
-		LOG_ERROR("insufficient memory to perform operation ");
+	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(Elf32_Phdr),
-			(uint8_t *)elf->segments, &read_bytes);
+	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(Elf32_Phdr)) {
+	if (read_bytes != elf->segment_count*sizeof(Elf64_Phdr)) {
 		LOG_ERROR("cannot read ELF segment headers, only partially read");
 		return ERROR_FILEIO_OPERATION_FAILED;
 	}
@@ -424,8 +544,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->segments64[i].p_type) == PT_LOAD) &&
+			(field64(elf, elf->segments64[i].p_filesz) != 0))
 			image->num_sections++;
 
 	assert(image->num_sections > 0);
@@ -441,44 +561,95 @@ 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->segments64[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->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 = 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->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 = field32(elf,
-						elf->segments[i].p_vaddr);
+				image->sections[j].base_address = field64(elf,
+						elf->segments64[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);
+				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 = field32(elf, elf->header->e_entry);
+	image->start_address = field64(elf, elf->header64->e_entry);
 
 	return ERROR_OK;
 }
 
-static int image_elf_read_section(struct image *image,
+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;
 
diff --git a/src/target/image.h b/src/target/image.h
index 53c27d8..c8d00d1 100644
--- a/src/target/image.h
+++ b/src/target/image.h
@@ -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,