X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Fimage.c;h=72a3828c36f0cbadef4b75b75d9f373f5962d93a;hb=9334cd451b299afe46703c59d13297ca48b684a4;hp=0c203f6b57b3df37c00c0c3eebe2982b49766858;hpb=29000b204d039bc1123027eba755329ab36a3dde;p=openocd.git diff --git a/src/target/image.c b/src/target/image.c index 0c203f6b57..72a3828c36 100644 --- a/src/target/image.c +++ b/src/target/image.c @@ -55,28 +55,26 @@ static int autodetect_image_type(image_t *image, char *url) /* read the first 4 bytes of image */ if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot open image: %s", fileio.error_str); - ERROR(image->error_str); return retval; } - if ((retval = fileio_read(&fileio, 9, buffer, &read_bytes)) != ERROR_OK) - { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image header: %s", fileio.error_str); - ERROR(image->error_str); - return ERROR_FILEIO_OPERATION_FAILED; - } - if (read_bytes != 9) + retval = fileio_read(&fileio, 9, buffer, &read_bytes); + + if (retval==ERROR_OK) { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image, only partially read"); - ERROR(image->error_str); - return ERROR_FILEIO_OPERATION_FAILED; + if (read_bytes != 9) + { + retval=ERROR_FILEIO_OPERATION_FAILED; + } } fileio_close(&fileio); + + if (retval!=ERROR_OK) + return retval; /* check header against known signatures */ if (strncmp((char*)buffer,ELFMAG,SELFMAG)==0) { - DEBUG("ELF image detected."); + LOG_DEBUG("ELF image detected."); image->type = IMAGE_ELF; } else if ((buffer[0]==':') /* record start byte */ @@ -89,7 +87,7 @@ static int autodetect_image_type(image_t *image, char *url) &&(buffer[7]=='0') /* record type : 00 -> 05 */ &&(buffer[8]>='0')&&(buffer[8]<'6')) { - DEBUG("IHEX image detected."); + LOG_DEBUG("IHEX image detected."); image->type = IMAGE_IHEX; } else if ((buffer[0] == 'S') /* record start byte */ @@ -98,7 +96,7 @@ static int autodetect_image_type(image_t *image, char *url) &&(isxdigit(buffer[3])) &&(buffer[1] >= '0') && (buffer[1] < '9')) { - DEBUG("S19 image detected."); + LOG_DEBUG("S19 image detected."); image->type = IMAGE_SRECORD; } else @@ -154,52 +152,37 @@ int image_ihex_buffer_complete(image_t *image) { image_ihex_t *ihex = image->type_private; fileio_t *fileio = &ihex->fileio; - u32 raw_bytes_read, raw_bytes; - int retval; u32 full_address = 0x0; - char *buffer = malloc(fileio->size); u32 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]; - - if ((retval = fileio_read(fileio, fileio->size, (u8*)buffer, &raw_bytes_read)) != ERROR_OK) - { - free(buffer); - ERROR("failed buffering IHEX file, read failed"); - return ERROR_FILEIO_OPERATION_FAILED; - } - - if (raw_bytes_read != fileio->size) - { - free(buffer); - ERROR("failed buffering complete IHEX file, only partially read"); - return ERROR_FILEIO_OPERATION_FAILED; - } ihex->buffer = malloc(fileio->size >> 1); - raw_bytes = 0x0; cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; section[image->num_sections].base_address = 0x0; section[image->num_sections].size = 0x0; section[image->num_sections].flags = 0; - while (raw_bytes < raw_bytes_read) + + while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK) { u32 count; u32 address; u32 record_type; u32 checksum; u8 cal_checksum = 0; + u32 bytes_read = 0; - if (sscanf(&buffer[raw_bytes], ":%2x%4x%2x", &count, &address, &record_type) != 3) + if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3) { return ERROR_IMAGE_FORMAT_ERROR; } - raw_bytes += 9; + bytes_read += 9; cal_checksum += (u8)count; cal_checksum += (u8)(address >> 8); @@ -228,9 +211,9 @@ int image_ihex_buffer_complete(image_t *image) while (count-- > 0) { - sscanf(&buffer[raw_bytes], "%2hhx", &ihex->buffer[cooked_bytes]); + sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]); cal_checksum += (u8)ihex->buffer[cooked_bytes]; - raw_bytes += 2; + bytes_read += 2; cooked_bytes += 1; section[image->num_sections].size += 1; full_address++; @@ -246,23 +229,61 @@ int image_ihex_buffer_complete(image_t *image) for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; - image->sections[i].base_address = section[i].base_address + - ((image->base_address_set) ? image->base_address : 0); + image->sections[i].base_address = section[i].base_address; image->sections[i].size = section[i].size; image->sections[i].flags = section[i].flags; } - free(buffer); return ERROR_OK; } + else if (record_type == 2) /* Linear Address Record */ + { + u16 upper_address; + + sscanf(&lpszLine[bytes_read], "%4hx", &upper_address); + cal_checksum += (u8)(upper_address >> 8); + cal_checksum += (u8)upper_address; + bytes_read += 4; + + if ((full_address >> 4) != upper_address) + { + /* we encountered a nonconsecutive location, create a new section, + * unless the current section has zero size, in which case this specifies + * the current section's base address + */ + if (section[image->num_sections].size != 0) + { + image->num_sections++; + section[image->num_sections].size = 0x0; + section[image->num_sections].flags = 0; + section[image->num_sections].private = &ihex->buffer[cooked_bytes]; + } + section[image->num_sections].base_address = + (full_address & 0xffff) | (upper_address << 4); + full_address = (full_address & 0xffff) | (upper_address << 4); + } + } + else if (record_type == 3) /* Start Segment Address Record */ + { + u32 dummy; + + /* "Start Segment Address Record" will not be supported */ + /* but we must consume it, and do not create an error. */ + while (count-- > 0) + { + sscanf(&lpszLine[bytes_read], "%2x", &dummy); + cal_checksum += (u8)dummy; + bytes_read += 2; + } + } else if (record_type == 4) /* Extended Linear Address Record */ { u16 upper_address; - sscanf(&buffer[raw_bytes], "%4hx", &upper_address); + sscanf(&lpszLine[bytes_read], "%4hx", &upper_address); cal_checksum += (u8)(upper_address >> 8); cal_checksum += (u8)upper_address; - raw_bytes += 4; + bytes_read += 4; if ((full_address >> 16) != upper_address) { @@ -286,44 +307,34 @@ int image_ihex_buffer_complete(image_t *image) { u32 start_address; - sscanf(&buffer[raw_bytes], "%8x", &start_address); + sscanf(&lpszLine[bytes_read], "%8x", &start_address); cal_checksum += (u8)(start_address >> 24); cal_checksum += (u8)(start_address >> 16); cal_checksum += (u8)(start_address >> 8); cal_checksum += (u8)start_address; - raw_bytes += 8; + bytes_read += 8; image->start_address_set = 1; image->start_address = be_to_h_u32((u8*)&start_address); } else { - free(buffer); - ERROR("unhandled IHEX record type: %i", record_type); + LOG_ERROR("unhandled IHEX record type: %i", record_type); return ERROR_IMAGE_FORMAT_ERROR; } - sscanf(&buffer[raw_bytes], "%2x", &checksum); - raw_bytes += 2; + sscanf(&lpszLine[bytes_read], "%2x", &checksum); + bytes_read += 2; if ((u8)checksum != (u8)(~cal_checksum + 1)) { /* checksum failed */ - free(buffer); - ERROR("incorrect record checksum found in IHEX file"); + LOG_ERROR("incorrect record checksum found in IHEX file"); return ERROR_IMAGE_CHECKSUM; } - - /* consume new-line character(s) */ - if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r')) - raw_bytes++; - - if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r')) - raw_bytes++; } - - free(buffer); - ERROR("premature end of IHEX file, no end-of-file record found"); + + LOG_ERROR("premature end of IHEX file, no end-of-file record found"); return ERROR_IMAGE_FORMAT_ERROR; } @@ -338,23 +349,23 @@ int image_elf_read_headers(image_t *image) if ((retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (u8*)elf->header, &read_bytes)) != ERROR_OK) { - ERROR("cannot read ELF file header, read failed"); + LOG_ERROR("cannot read ELF file header, read failed"); return ERROR_FILEIO_OPERATION_FAILED; } if (read_bytes != sizeof(Elf32_Ehdr)) { - ERROR("cannot read ELF file header, only partially read"); + LOG_ERROR("cannot read ELF file header, only partially read"); return ERROR_FILEIO_OPERATION_FAILED; } if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG)!=0) { - ERROR("invalid ELF file, bad magic number"); + LOG_ERROR("invalid ELF file, bad magic number"); return ERROR_IMAGE_FORMAT_ERROR; } if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32) { - ERROR("invalid ELF file, only 32bits files are supported"); + LOG_ERROR("invalid ELF file, only 32bits files are supported"); return ERROR_IMAGE_FORMAT_ERROR; } @@ -363,27 +374,33 @@ int image_elf_read_headers(image_t *image) if ((elf->endianness!=ELFDATA2LSB) &&(elf->endianness!=ELFDATA2MSB)) { - ERROR("invalid ELF file, unknown endianess setting"); + LOG_ERROR("invalid ELF file, unknown endianess setting"); return ERROR_IMAGE_FORMAT_ERROR; } elf->segment_count = field16(elf,elf->header->e_phnum); if (elf->segment_count==0) { - ERROR("invalid ELF file, no program headers"); + LOG_ERROR("invalid ELF file, no program headers"); return ERROR_IMAGE_FORMAT_ERROR; } + if ((retval = fileio_seek(&elf->fileio, field32(elf,elf->header->e_phoff))) != 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 ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK) { - ERROR("cannot read ELF segment headers, read failed"); + LOG_ERROR("cannot read ELF segment headers, read failed"); return retval; } if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr)) { - ERROR("cannot read ELF segment headers, only partially read"); + LOG_ERROR("cannot read ELF segment headers, only partially read"); return ERROR_FILEIO_OPERATION_FAILED; } @@ -398,7 +415,7 @@ 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->sections[j].size = field32(elf,elf->segments[i].p_memsz); + image->sections[j].size = field32(elf,elf->segments[i].p_filesz); 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); @@ -421,24 +438,24 @@ int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8 *size_read = 0; - DEBUG("load segment %d at 0x%x (sz=0x%x)",section,offset,size); + LOG_DEBUG("load segment %d at 0x%x (sz=0x%x)",section,offset,size); /* read initialized data in current segment if any */ if (offsetp_filesz)) { /* maximal size present in file for the current segment */ read_size = MIN(size, field32(elf,segment->p_filesz)-offset); - DEBUG("read elf: size = 0x%x at 0x%x",read_size, + LOG_DEBUG("read elf: size = 0x%x at 0x%x",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) { - ERROR("cannot find ELF segment content, seek failed"); + LOG_ERROR("cannot find ELF segment content, seek failed"); return retval; } if ((retval = fileio_read(&elf->fileio, read_size, buffer, &really_read)) != ERROR_OK) { - ERROR("cannot read ELF segment content, read failed"); + LOG_ERROR("cannot read ELF segment content, read failed"); return retval; } buffer += read_size; @@ -449,15 +466,6 @@ int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8 if (!size) return ERROR_OK; } - /* if there is remaining zeroed area in current segment */ - if (offsetp_memsz)) - { - /* fill zeroed part (BSS) of the segment */ - read_size = MIN(size, field32(elf,segment->p_memsz)-offset); - DEBUG("zero fill: size = 0x%x",read_size); - memset(buffer,0,read_size); - *size_read += read_size; - } return ERROR_OK; } @@ -466,33 +474,16 @@ int image_mot_buffer_complete(image_t *image) { image_mot_t *mot = image->type_private; fileio_t *fileio = &mot->fileio; - u32 raw_bytes_read, raw_bytes; - int retval; u32 full_address = 0x0; - char *buffer = malloc(fileio->size); u32 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]; - if ((retval = fileio_read(fileio, fileio->size, (u8*)buffer, &raw_bytes_read)) != ERROR_OK) - { - free(buffer); - ERROR("failed buffering S19 file, read failed"); - return ERROR_FILEIO_OPERATION_FAILED; - } - - if (raw_bytes_read != fileio->size) - { - free(buffer); - ERROR("failed buffering complete IHEX file, only partially read"); - return ERROR_FILEIO_OPERATION_FAILED; - } - mot->buffer = malloc(fileio->size >> 1); - raw_bytes = 0x0; cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &mot->buffer[cooked_bytes]; @@ -500,21 +491,22 @@ int image_mot_buffer_complete(image_t *image) section[image->num_sections].size = 0x0; section[image->num_sections].flags = 0; - while (raw_bytes < raw_bytes_read) + while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK) { u32 count; u32 address; u32 record_type; u32 checksum; u8 cal_checksum = 0; - + u32 bytes_read = 0; + /* get record type and record length */ - if (sscanf(&buffer[raw_bytes], "S%1x%2x", &record_type, &count) != 2) + if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2) { return ERROR_IMAGE_FORMAT_ERROR; } - raw_bytes += 4; + bytes_read += 4; cal_checksum += (u8)count; /* skip checksum byte */ @@ -526,9 +518,9 @@ int image_mot_buffer_complete(image_t *image) int iValue; while (count-- > 0) { - sscanf(&buffer[raw_bytes], "%2x", &iValue); + sscanf(&lpszLine[bytes_read], "%2x", &iValue); cal_checksum += (u8)iValue; - raw_bytes += 2; + bytes_read += 2; } } else if (record_type >= 1 && record_type <= 3) @@ -537,31 +529,31 @@ int image_mot_buffer_complete(image_t *image) { case 1: /* S1 - 16 bit address data record */ - sscanf(&buffer[raw_bytes], "%4x", &address); + sscanf(&lpszLine[bytes_read], "%4x", &address); cal_checksum += (u8)(address >> 8); cal_checksum += (u8)address; - raw_bytes += 4; + bytes_read += 4; count -=2; break; case 2: /* S2 - 24 bit address data record */ - sscanf(&buffer[raw_bytes], "%6x", &address); + sscanf(&lpszLine[bytes_read], "%6x", &address); cal_checksum += (u8)(address >> 16); cal_checksum += (u8)(address >> 8); cal_checksum += (u8)address; - raw_bytes += 6; + bytes_read += 6; count -=3; break; case 3: /* S3 - 32 bit address data record */ - sscanf(&buffer[raw_bytes], "%8x", &address); + sscanf(&lpszLine[bytes_read], "%8x", &address); cal_checksum += (u8)(address >> 24); cal_checksum += (u8)(address >> 16); cal_checksum += (u8)(address >> 8); cal_checksum += (u8)address; - raw_bytes += 8; + bytes_read += 8; count -=4; break; @@ -580,21 +572,32 @@ int image_mot_buffer_complete(image_t *image) section[image->num_sections].flags = 0; section[image->num_sections].private = &mot->buffer[cooked_bytes]; } - section[image->num_sections].base_address = - full_address | address; - full_address = full_address | address; + section[image->num_sections].base_address = address; + full_address = address; } while (count-- > 0) { - sscanf(&buffer[raw_bytes], "%2hhx", &mot->buffer[cooked_bytes]); + sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]); cal_checksum += (u8)mot->buffer[cooked_bytes]; - raw_bytes += 2; + bytes_read += 2; cooked_bytes += 1; section[image->num_sections].size += 1; full_address++; } } + else if (record_type == 5) + { + /* S5 is the data count record, we ignore it */ + u32 dummy; + + while (count-- > 0) + { + sscanf(&lpszLine[bytes_read], "%2x", &dummy); + cal_checksum += (u8)dummy; + bytes_read += 2; + } + } else if (record_type >= 7 && record_type <= 9) { /* S7, S8, S9 - ending records for 32, 24 and 16bit */ @@ -605,45 +608,33 @@ int image_mot_buffer_complete(image_t *image) for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; - image->sections[i].base_address = section[i].base_address + - ((image->base_address_set) ? image->base_address : 0); + image->sections[i].base_address = section[i].base_address; image->sections[i].size = section[i].size; image->sections[i].flags = section[i].flags; } - free(buffer); return ERROR_OK; } else { - free(buffer); - ERROR("unhandled S19 record type: %i", record_type); + LOG_ERROR("unhandled S19 record type: %i", record_type); return ERROR_IMAGE_FORMAT_ERROR; } /* account for checksum, will always be 0xFF */ - sscanf(&buffer[raw_bytes], "%2x", &checksum); + sscanf(&lpszLine[bytes_read], "%2x", &checksum); cal_checksum += (u8)checksum; - raw_bytes += 2; + bytes_read += 2; if( cal_checksum != 0xFF ) { /* checksum failed */ - free(buffer); - ERROR("incorrect record checksum found in S19 file"); + LOG_ERROR("incorrect record checksum found in S19 file"); return ERROR_IMAGE_CHECKSUM; } - - /* consume new-line character(s) */ - if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r')) - raw_bytes++; - - if ((buffer[raw_bytes] == '\n') || (buffer[raw_bytes] == '\r')) - raw_bytes++; } - - free(buffer); - ERROR("premature end of S19 file, no end-of-file record found"); + + LOG_ERROR("premature end of S19 file, no end-of-file record found"); return ERROR_IMAGE_FORMAT_ERROR; } @@ -664,8 +655,6 @@ int image_open(image_t *image, char *url, char *type_string) if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { - strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING); - ERROR(image->error_str); return retval; } @@ -674,11 +663,6 @@ int image_open(image_t *image, char *url, char *type_string) image->sections[0].base_address = 0x0; image->sections[0].size = image_binary->fileio.size; image->sections[0].flags = 0; - - if (image->base_address_set == 1) - image->sections[0].base_address = image->base_address; - - return ERROR_OK; } else if (image->type == IMAGE_IHEX) { @@ -688,16 +672,12 @@ int image_open(image_t *image, char *url, char *type_string) if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { - strncpy(image->error_str, image_ihex->fileio.error_str, IMAGE_MAX_ERROR_STRING); - ERROR(image->error_str); return retval; } if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK) { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, - "failed buffering IHEX image, check daemon output for additional information"); - ERROR(image->error_str); + LOG_ERROR("failed buffering IHEX image, check daemon output for additional information"); fileio_close(&image_ihex->fileio); return retval; } @@ -710,16 +690,11 @@ int image_open(image_t *image, char *url, char *type_string) if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { - strncpy(image->error_str, image_elf->fileio.error_str, IMAGE_MAX_ERROR_STRING); - ERROR(image->error_str); return retval; } if ((retval = image_elf_read_headers(image)) != ERROR_OK) { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, - "failed to read ELF headers, check daemon output for additional information"); - ERROR(image->error_str); fileio_close(&image_elf->fileio); return retval; } @@ -748,16 +723,12 @@ int image_open(image_t *image, char *url, char *type_string) if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { - strncpy(image->error_str, image_mot->fileio.error_str, IMAGE_MAX_ERROR_STRING); - ERROR(image->error_str); return retval; } if ((retval = image_mot_buffer_complete(image)) != ERROR_OK) { - snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, - "failed buffering S19 image, check daemon output for additional information"); - ERROR(image->error_str); + LOG_ERROR("failed buffering S19 image, check daemon output for additional information"); fileio_close(&image_mot->fileio); return retval; } @@ -768,6 +739,21 @@ int image_open(image_t *image, char *url, char *type_string) image->sections = NULL; image->type_private = NULL; } + + if (image->base_address_set) + { + /* relocate */ + int section; + for (section=0; section < image->num_sections; section++) + { + image->sections[section].base_address+=image->base_address; + } + /* we're done relocating. The two statements below are mainly + * for documenation purposes: stop anyone from empirically + * thinking they should use these values henceforth. */ + image->base_address=0; + image->base_address_set=0; + } return retval; }; @@ -779,7 +765,7 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu /* don't read past the end of a section */ if (offset + size > image->sections[section].size) { - DEBUG("read past end of section: 0x%8.8x + 0x%8.8x > 0x%8.8x", + LOG_DEBUG("read past end of section: 0x%8.8x + 0x%8.8x > 0x%8.8x", offset, size, image->sections[section].size); return ERROR_INVALID_ARGUMENTS; } @@ -795,14 +781,12 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu /* seek to offset */ if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK) { - strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING); return retval; } /* return requested bytes */ if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK) { - strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING); return retval; } } @@ -810,7 +794,6 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu { memcpy(buffer, (u8*)image->sections[section].private + offset, size); *size_read = size; - image->error_str[0] = '\0'; return ERROR_OK; } @@ -840,6 +823,7 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK) { free(image_memory->cache); + image_memory->cache = NULL; return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE; } image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1); @@ -860,7 +844,6 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu { memcpy(buffer, (u8*)image->sections[section].private + offset, size); *size_read = size; - image->error_str[0] = '\0'; return ERROR_OK; } @@ -868,7 +851,6 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu { memcpy(buffer, (u8*)image->sections[section].private + offset, size); *size_read = size; - image->error_str[0] = '\0'; return ERROR_OK; } @@ -928,7 +910,10 @@ int image_close(image_t *image) fileio_close(&image_ihex->fileio); if (image_ihex->buffer) + { free(image_ihex->buffer); + image_ihex->buffer = NULL; + } } else if (image->type == IMAGE_ELF) { @@ -937,17 +922,26 @@ int image_close(image_t *image) fileio_close(&image_elf->fileio); if (image_elf->header) + { free(image_elf->header); + image_elf->header = NULL; + } if (image_elf->segments) + { free(image_elf->segments); + image_elf->segments = NULL; + } } else if (image->type == IMAGE_MEMORY) { image_memory_t *image_memory = image->type_private; if (image_memory->cache) + { free(image_memory->cache); + image_memory->cache = NULL; + } } else if (image->type == IMAGE_SRECORD) { @@ -956,7 +950,10 @@ int image_close(image_t *image) fileio_close(&image_mot->fileio); if (image_mot->buffer) + { free(image_mot->buffer); + image_mot->buffer = NULL; + } } else if (image->type == IMAGE_BUILDER) { @@ -965,14 +962,53 @@ int image_close(image_t *image) for (i = 0; i < image->num_sections; i++) { free(image->sections[i].private); + image->sections[i].private = NULL; } } if (image->type_private) + { free(image->type_private); + image->type_private = NULL; + } if (image->sections) + { free(image->sections); + image->sections = NULL; + } return ERROR_OK; } + +static u32 crc32_table[256] = {0, 0}; + +int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum) +{ + u32 crc = 0xffffffff; + + if (!crc32_table[1]) + { + /* 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; + } + } + + while (nbytes--) + { + /* as per gdb */ + crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255]; + } + + *checksum = crc; + return ERROR_OK; +} + +