- flash autoerase <on|off> cmd added, default is off - flash banks are calculated and erased prior to write (flash write_image only)

- corrected array overrun in armv7m.c
- corrected breakpoint memory allocation bug
- image read now uses fgets, vastly improves reading of large files
- improved hex file reading, support for Linear Address Record added

git-svn-id: svn://svn.berlios.de/openocd/trunk@208 b42882b7-edfa-0310-969c-e2dbd0fdcd60

3 files changed, 65 insertions, 92 deletions

diff --git a/src/target/armv7m.c b/src/target/armv7m.c
index 96864fd1..7010b5c0 100644
--- a/src/target/armv7m.c
+++ b/src/target/armv7m.c
@@ -186,7 +186,7 @@ int armv7m_restore_context(target_t *target)
 	if (armv7m->pre_restore_context)
 		armv7m->pre_restore_context(target);
 		
-	for (i = ARMV7NUMCOREREGS; i >= 0; i--)
+	for (i = ARMV7NUMCOREREGS-1; i >= 0; i--)
 	{
 		if (armv7m->core_cache->reg_list[i].dirty)
 		{
diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c
index cc38d029..f52ff306 100644
--- a/src/target/breakpoints.c
+++ b/src/target/breakpoints.c
@@ -62,7 +62,7 @@ int breakpoint_add(target_t *target, u32 address, u32 length, enum breakpoint_ty
 	(*breakpoint_p)->length = length;
 	(*breakpoint_p)->type = type;
 	(*breakpoint_p)->set = 0;
-	(*breakpoint_p)->orig_instr = malloc(CEIL(length, 8));
+	(*breakpoint_p)->orig_instr = malloc(length);
 	(*breakpoint_p)->next = NULL;
 	
 	if ((retval = target->type->add_breakpoint(target, *breakpoint_p)) != ERROR_OK)
diff --git a/src/target/image.c b/src/target/image.c
index 0c203f6b..dbb1c2ab 100644
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -154,52 +154,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 +213,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++;
@@ -252,17 +237,43 @@ int image_ihex_buffer_complete(image_t *image)
 				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 == 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,43 +297,33 @@ 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);
 			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");
 			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");
 	return ERROR_IMAGE_FORMAT_ERROR;
 }
@@ -466,33 +467,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 +484,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 +511,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 +522,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,16 +565,15 @@ 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++;
@@ -611,38 +595,27 @@ int image_mot_buffer_complete(image_t *image)
 				image->sections[i].flags = section[i].flags;
 			}
 			
-			free(buffer);
 			return ERROR_OK;
 		}
 		else
 		{
-			free(buffer);
 			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");
 			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");
 	return ERROR_IMAGE_FORMAT_ERROR;
 }