jtag: jtag_add_ir_scan() now takes a single field

[openocd.git] / src / target / image.c

diff --git a/src/target/image.c b/src/target/image.c
index 8774c2517ba6e1f500e1f353466d348503e1595a..f8d05292c853cf5189b5337b5fc8c3771d3a2cbd 100644 (file)
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -32,7 +32,7 @@
 
 #include "image.h"
 #include "target.h"
-#include "log.h"
+#include <helper/log.h>
 
 
 /* convert ELF header field to host endianness */
@@ -147,18 +147,16 @@ static int identify_image_type(struct image *image, const char *type_string, con
        return ERROR_OK;
 }
 
-static int image_ihex_buffer_complete(struct image *image)
+static int image_ihex_buffer_complete_inner(struct image *image, char *lpszLine, struct imageection *section)
 {
        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 */
-       struct imageection section[IMAGE_MAX_SECTIONS];
 
        ihex->buffer = malloc(fileio->size >> 1);
        cooked_bytes = 0x0;
@@ -357,6 +355,35 @@ static int image_ihex_buffer_complete(struct image *image)
        return ERROR_IMAGE_FORMAT_ERROR;
 }
 
+/**
+ * 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 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;
@@ -499,18 +526,16 @@ static int image_elf_read_section(struct image *image, int section, uint32_t off
        return ERROR_OK;
 }
 
-static int image_mot_buffer_complete(struct image *image)
+static int image_mot_buffer_complete_inner(struct image *image, char *lpszLine, struct imageection *section)
 {
        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 */
-       struct imageection section[IMAGE_MAX_SECTIONS];
 
        mot->buffer = malloc(fileio->size >> 1);
        cooked_bytes = 0x0;
@@ -669,6 +694,36 @@ static int image_mot_buffer_complete(struct image *image)
        return ERROR_IMAGE_FORMAT_ERROR;
 }
 
+/**
+ * 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;
@@ -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)