X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fimage.c;h=f8d05292c853cf5189b5337b5fc8c3771d3a2cbd;hp=9a9c9553b87f1b66bdb71da7ebf684fb1bdb8a4f;hb=c79cca04bed78839a18e73f3996805eb8001a812;hpb=9f212b01be20da43ba534ad33b20419779c89335 diff --git a/src/target/image.c b/src/target/image.c index 9a9c9553b8..f8d05292c8 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,18 +147,16 @@ 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 imageection *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); cooked_bytes = 0x0; @@ -175,7 +173,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 +230,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 imageection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -357,10 +355,39 @@ 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) { - image_elf_t *elf = image->type_private; - uint32_t read_bytes; + char *lpszLine = malloc(1023); + if (lpszLine == NULL) + { + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + struct imageection *section = malloc(sizeof(struct imageection) * 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) +{ + struct image_elf *elf = image->type_private; + size_t read_bytes; uint32_t i,j; int retval; @@ -439,7 +466,7 @@ static int image_elf_read_headers(image_t *image) if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0)) image->num_sections++; /* 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 imageection)); 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)) @@ -458,11 +485,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 +501,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) @@ -499,18 +526,16 @@ 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 imageection *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); cooked_bytes = 0x0; @@ -635,7 +660,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 imageection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -669,7 +694,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 imageection *section = malloc(sizeof(struct imageection) * 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,9 +735,9 @@ 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) { @@ -690,16 +745,16 @@ int image_open(image_t *image, const char *url, const char *type_string) } image->num_sections = 1; - image->sections = malloc(sizeof(image_section_t)); + image->sections = malloc(sizeof(struct imageection)); image->sections[0].base_address = 0x0; image->sections[0].size = image_binary->fileio.size; 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 +770,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 +787,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 +795,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 imageection)); 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 +811,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 +852,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; @@ -811,7 +866,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si 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) @@ -842,7 +897,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,9 +952,9 @@ 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 imageection *section; /* only image builder supports adding sections */ if (image->type != IMAGE_BUILDER) @@ -923,7 +978,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 imageection) * image->num_sections); section = &image->sections[image->num_sections - 1]; section->base_address = base; section->size = size; @@ -934,17 +989,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 +1011,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 +1029,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 +1039,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 +1078,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)