X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fimage.c;h=c0aabecd5838cf47c3628053fbc81292da90a643;hp=9a9c9553b87f1b66bdb71da7ebf684fb1bdb8a4f;hb=4668bd264cfe64c3e3ddd0f75cb5bf2e5e85f717;hpb=9f212b01be20da43ba534ad33b20419779c89335 diff --git a/src/target/image.c b/src/target/image.c index 9a9c9553b8..c0aabecd58 100644 --- a/src/target/image.c +++ b/src/target/image.c @@ -32,7 +32,7 @@ #include "image.h" #include "target.h" -#include "log.h" +#include /* convert ELF header field to host endianness */ @@ -44,11 +44,11 @@ ((elf->endianness == ELFDATA2LSB)? \ le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field)) -static int autodetect_image_type(image_t *image, const char *url) +static int autodetect_image_type(struct image *image, const char *url) { int retval; struct fileio fileio; - uint32_t read_bytes; + size_t read_bytes; uint8_t buffer[9]; /* read the first 4 bytes of image */ @@ -106,7 +106,7 @@ static int autodetect_image_type(image_t *image, const char *url) return ERROR_OK; } -static int identify_image_type(image_t *image, const char *type_string, const char *url) +static int identify_image_type(struct image *image, const char *type_string, const char *url) { if (type_string) { @@ -147,20 +147,24 @@ static int identify_image_type(image_t *image, const char *type_string, const ch return ERROR_OK; } -static int image_ihex_buffer_complete(image_t *image) +static int image_ihex_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section) { - image_ihex_t *ihex = image->type_private; + struct image_ihex *ihex = image->type_private; struct fileio *fileio = &ihex->fileio; uint32_t full_address = 0x0; uint32_t cooked_bytes; int i; - char lpszLine[1023]; /* we can't determine the number of sections that we'll have to create ahead of time, * so we locally hold them until parsing is finished */ - image_section_t section[IMAGE_MAX_SECTIONS]; - ihex->buffer = malloc(fileio->size >> 1); + int filesize; + int retval; + retval = fileio_size(fileio, &filesize); + if (retval != ERROR_OK) + return retval; + + ihex->buffer = malloc(filesize >> 1); cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; @@ -175,7 +179,7 @@ static int image_ihex_buffer_complete(image_t *image) uint32_t record_type; uint32_t checksum; uint8_t cal_checksum = 0; - uint32_t bytes_read = 0; + size_t bytes_read = 0; if (sscanf(&lpszLine[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32 , &count, &address, &record_type) != 3) { @@ -232,7 +236,7 @@ static int image_ihex_buffer_complete(image_t *image) image->num_sections++; /* copy section information */ - image->sections = malloc(sizeof(image_section_t) * image->num_sections); + image->sections = malloc(sizeof(struct imagesection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -343,7 +347,6 @@ static int image_ihex_buffer_complete(image_t *image) } sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum); - bytes_read += 2; if ((uint8_t)checksum != (uint8_t)(~cal_checksum + 1)) { @@ -357,12 +360,42 @@ static int image_ihex_buffer_complete(image_t *image) return ERROR_IMAGE_FORMAT_ERROR; } -static int image_elf_read_headers(image_t *image) +/** + * Allocate memory dynamically instead of on the stack. This + * is important w/embedded hosts. + */ +static int image_ihex_buffer_complete(struct image *image) +{ + char *lpszLine = malloc(1023); + if (lpszLine == NULL) + { + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS); + if (section == NULL) + { + free(lpszLine); + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + int retval; + + retval = image_ihex_buffer_complete_inner(image, lpszLine, section); + + free(section); + free(lpszLine); + + return retval; +} + +static int image_elf_read_headers(struct image *image) { - image_elf_t *elf = image->type_private; - uint32_t read_bytes; + struct image_elf *elf = image->type_private; + size_t read_bytes; uint32_t i,j; int retval; + uint32_t nload,load_to_vaddr=0; elf->header = malloc(sizeof(Elf32_Ehdr)); @@ -398,7 +431,7 @@ static int image_elf_read_headers(image_t *image) if ((elf->endianness != ELFDATA2LSB) &&(elf->endianness != ELFDATA2MSB)) { - LOG_ERROR("invalid ELF file, unknown endianess setting"); + LOG_ERROR("invalid ELF file, unknown endianness setting"); return ERROR_IMAGE_FORMAT_ERROR; } @@ -438,14 +471,39 @@ static int image_elf_read_headers(image_t *image) 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)) 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->segments[i].p_paddr != 0) + break; + else if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_memsz) != 0)) + ++nload; + + if (i >= elf->segment_count && nload > 1) + load_to_vaddr = 1; + /* alloc and fill sections array with loadable segments */ - image->sections = malloc(image->num_sections * sizeof(image_section_t)); + image->sections = malloc(image->num_sections * sizeof(struct imagesection)); 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); - image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr); + if (load_to_vaddr) + image->sections[j].base_address = field32(elf,elf->segments[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); j++; @@ -458,11 +516,11 @@ static int image_elf_read_headers(image_t *image) return ERROR_OK; } -static int image_elf_read_section(image_t *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, uint32_t *size_read) +static int image_elf_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read) { - image_elf_t *elf = image->type_private; + struct image_elf *elf = image->type_private; Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private; - uint32_t read_size,really_read; + size_t read_size,really_read; int retval; *size_read = 0; @@ -474,7 +532,7 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset, { /* 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%" PRIx32 " at 0x%" PRIx32 "",read_size, + LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size, field32(elf,segment->p_offset) + offset); /* read initialized area of the segment */ if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset) + offset)) != ERROR_OK) @@ -487,9 +545,7 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset, LOG_ERROR("cannot read ELF segment content, read failed"); return retval; } - buffer += read_size; size -= read_size; - offset += read_size; *size_read += read_size; /* need more data ? */ if (!size) @@ -499,20 +555,24 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset, return ERROR_OK; } -static int image_mot_buffer_complete(image_t *image) +static int image_mot_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section) { - image_mot_t *mot = image->type_private; + struct image_mot *mot = image->type_private; struct fileio *fileio = &mot->fileio; uint32_t full_address = 0x0; uint32_t cooked_bytes; int i; - char lpszLine[1023]; /* we can't determine the number of sections that we'll have to create ahead of time, * so we locally hold them until parsing is finished */ - image_section_t section[IMAGE_MAX_SECTIONS]; - mot->buffer = malloc(fileio->size >> 1); + int retval; + int filesize; + retval = fileio_size(fileio, &filesize); + if (retval != ERROR_OK) + return retval; + + mot->buffer = malloc(filesize >> 1); cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &mot->buffer[cooked_bytes]; @@ -635,7 +695,7 @@ static int image_mot_buffer_complete(image_t *image) image->num_sections++; /* copy section information */ - image->sections = malloc(sizeof(image_section_t) * image->num_sections); + image->sections = malloc(sizeof(struct imagesection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -655,7 +715,6 @@ static int image_mot_buffer_complete(image_t *image) /* account for checksum, will always be 0xFF */ sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum); cal_checksum += (uint8_t)checksum; - bytes_read += 2; if (cal_checksum != 0xFF) { @@ -669,7 +728,37 @@ static int image_mot_buffer_complete(image_t *image) return ERROR_IMAGE_FORMAT_ERROR; } -int image_open(image_t *image, const char *url, const char *type_string) +/** + * Allocate memory dynamically instead of on the stack. This + * is important w/embedded hosts. + */ +static int image_mot_buffer_complete(struct image *image) +{ + char *lpszLine = malloc(1023); + if (lpszLine == NULL) + { + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS); + if (section == NULL) + { + free(lpszLine); + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + int retval; + + retval = image_mot_buffer_complete_inner(image, lpszLine, section); + + free(section); + free(lpszLine); + + return retval; +} + + +int image_open(struct image *image, const char *url, const char *type_string) { int retval = ERROR_OK; @@ -680,26 +769,33 @@ int image_open(image_t *image, const char *url, const char *type_string) if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary; + struct image_binary *image_binary; - image_binary = image->type_private = malloc(sizeof(image_binary_t)); + image_binary = image->type_private = malloc(sizeof(struct image_binary)); if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { return retval; } + int filesize; + retval = fileio_size(&image_binary->fileio, &filesize); + if (retval != ERROR_OK) + { + fileio_close(&image_binary->fileio); + return retval; + } image->num_sections = 1; - image->sections = malloc(sizeof(image_section_t)); + image->sections = malloc(sizeof(struct imagesection)); image->sections[0].base_address = 0x0; - image->sections[0].size = image_binary->fileio.size; + image->sections[0].size = filesize; image->sections[0].flags = 0; } else if (image->type == IMAGE_IHEX) { - image_ihex_t *image_ihex; + struct image_ihex *image_ihex; - image_ihex = image->type_private = malloc(sizeof(image_ihex_t)); + image_ihex = image->type_private = malloc(sizeof(struct image_ihex)); if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { @@ -715,9 +811,9 @@ int image_open(image_t *image, const char *url, const char *type_string) } else if (image->type == IMAGE_ELF) { - image_elf_t *image_elf; + struct image_elf *image_elf; - image_elf = image->type_private = malloc(sizeof(image_elf_t)); + image_elf = image->type_private = malloc(sizeof(struct image_elf)); if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { @@ -732,7 +828,7 @@ int image_open(image_t *image, const char *url, const char *type_string) } else if (image->type == IMAGE_MEMORY) { - target_t *target = get_target(url); + struct target *target = get_target(url); if (target == NULL) { @@ -740,15 +836,15 @@ int image_open(image_t *image, const char *url, const char *type_string) return ERROR_FAIL; } - image_memory_t *image_memory; + struct image_memory *image_memory; image->num_sections = 1; - image->sections = malloc(sizeof(image_section_t)); + image->sections = malloc(sizeof(struct imagesection)); image->sections[0].base_address = 0x0; image->sections[0].size = 0xffffffff; image->sections[0].flags = 0; - image_memory = image->type_private = malloc(sizeof(image_memory_t)); + image_memory = image->type_private = malloc(sizeof(struct image_memory)); image_memory->target = target; image_memory->cache = NULL; @@ -756,9 +852,9 @@ int image_open(image_t *image, const char *url, const char *type_string) } else if (image->type == IMAGE_SRECORD) { - image_mot_t *image_mot; + struct image_mot *image_mot; - image_mot = image->type_private = malloc(sizeof(image_mot_t)); + image_mot = image->type_private = malloc(sizeof(struct image_mot)); if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { @@ -797,7 +893,7 @@ int image_open(image_t *image, const char *url, const char *type_string) return retval; }; -int image_read_section(image_t *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, uint32_t *size_read) +int image_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read) { int retval; @@ -806,16 +902,16 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si { LOG_DEBUG("read past end of section: 0x%8.8" PRIx32 " + 0x%8.8" PRIx32 " > 0x%8.8" PRIx32 "", offset, size, image->sections[section].size); - return ERROR_INVALID_ARGUMENTS; + return ERROR_COMMAND_SYNTAX_ERROR; } if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary = image->type_private; + struct image_binary *image_binary = image->type_private; /* only one section in a plain binary */ if (section != 0) - return ERROR_INVALID_ARGUMENTS; + return ERROR_COMMAND_SYNTAX_ERROR; /* seek to offset */ if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK) @@ -842,7 +938,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si } else if (image->type == IMAGE_MEMORY) { - image_memory_t *image_memory = image->type_private; + struct image_memory *image_memory = image->type_private; uint32_t address = image->sections[section].base_address + offset; *size_read = 0; @@ -897,13 +993,13 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si return ERROR_OK; } -int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, uint8_t *data) +int image_add_section(struct image *image, uint32_t base, uint32_t size, int flags, uint8_t *data) { - image_section_t *section; + struct imagesection *section; /* only image builder supports adding sections */ if (image->type != IMAGE_BUILDER) - return ERROR_INVALID_ARGUMENTS; + return ERROR_COMMAND_SYNTAX_ERROR; /* see if there's a previous section */ if (image->num_sections) @@ -923,7 +1019,7 @@ int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, u /* allocate new section */ image->num_sections++; - image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections); + image->sections = realloc(image->sections, sizeof(struct imagesection) * image->num_sections); section = &image->sections[image->num_sections - 1]; section->base_address = base; section->size = size; @@ -934,17 +1030,17 @@ int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, u return ERROR_OK; } -void image_close(image_t *image) +void image_close(struct image *image) { if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary = image->type_private; + struct image_binary *image_binary = image->type_private; fileio_close(&image_binary->fileio); } else if (image->type == IMAGE_IHEX) { - image_ihex_t *image_ihex = image->type_private; + struct image_ihex *image_ihex = image->type_private; fileio_close(&image_ihex->fileio); @@ -956,7 +1052,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_ELF) { - image_elf_t *image_elf = image->type_private; + struct image_elf *image_elf = image->type_private; fileio_close(&image_elf->fileio); @@ -974,7 +1070,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_MEMORY) { - image_memory_t *image_memory = image->type_private; + struct image_memory *image_memory = image->type_private; if (image_memory->cache) { @@ -984,7 +1080,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_SRECORD) { - image_mot_t *image_mot = image->type_private; + struct image_mot *image_mot = image->type_private; fileio_close(&image_mot->fileio); @@ -1023,17 +1119,23 @@ int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes, uint32_t* checksu uint32_t crc = 0xffffffff; LOG_DEBUG("Calculating checksum"); - uint32_t crc32_table[256]; + static uint32_t crc32_table[256]; - /* Initialize the CRC table and the decoding table. */ - int i, j; - unsigned int c; - for (i = 0; i < 256; i++) + static bool first_init = false; + if (!first_init) { - /* as per gdb */ - for (c = i << 24, j = 8; j > 0; --j) - c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); - crc32_table[i] = c; + /* Initialize the CRC table and the decoding table. */ + int i, j; + unsigned int c; + for (i = 0; i < 256; i++) + { + /* as per gdb */ + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + + first_init = true; } while (nbytes > 0)