image_t -> struct image

Remove misleading typedef and redundant suffix from struct image.

Also removes the typedef from enum image_type, as it is used in
image.h only.

diff --git a/src/flash/ecos.c b/src/flash/ecos.c
index 450bd5b70a79c5183e9c37b09bcf6aca0504d8bf..57df1e7f0c5fbca049cb016cfe1f3feaf603ac2f 100644 (file)
--- a/src/flash/ecos.c
+++ b/src/flash/ecos.c
@@ -153,7 +153,7 @@ static int loadDriver(struct ecosflash_flash_bank *info)
 {
        uint32_t buf_cnt;
        uint32_t image_size;
-       image_t image;
+       struct image image;
 
        image.base_address_set = 0;
        image.start_address_set = 0;

diff --git a/src/flash/flash.c b/src/flash/flash.c
index 22e272150575b713e0bc8dc1b9329a033e691b83..a8da5565c15e21a1beee8023d70713e557bfaba8 100644 (file)
--- a/src/flash/flash.c
+++ b/src/flash/flash.c
@@ -31,7 +31,7 @@
 #include "image.h"
 #include "time_support.h"
 
-static int flash_write_unlock(target_t *target, image_t *image, uint32_t *written, int erase, bool unlock);
+static int flash_write_unlock(target_t *target, struct image *image, uint32_t *written, int erase, bool unlock);
 
 /* flash drivers
  */
@@ -617,7 +617,7 @@ COMMAND_HANDLER(handle_flash_write_image_command)
 {
        target_t *target = get_current_target(cmd_ctx);
 
-       image_t image;
+       struct image image;
        uint32_t written;
 
        int retval;
@@ -966,7 +966,7 @@ static int flash_unlock_address_range(target_t *target, uint32_t addr, uint32_t
 
 
 /* write (optional verify) an image to flash memory of the given target */
-static int flash_write_unlock(target_t *target, image_t *image, uint32_t *written, int erase, bool unlock)
+static int flash_write_unlock(target_t *target, struct image *image, uint32_t *written, int erase, bool unlock)
 {
        int retval = ERROR_OK;
 
@@ -1125,7 +1125,7 @@ static int flash_write_unlock(target_t *target, image_t *image, uint32_t *writte
        return retval;
 }
 
-int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
+int flash_write(target_t *target, struct image *image, uint32_t *written, int erase)
 {
        return flash_write_unlock(target, image, written, erase, false);
 }

diff --git a/src/flash/flash.h b/src/flash/flash.h
index 9cd592321c3b3a946f8e34b06f9c97e81882730b..eeacc756cfa2d1b0452806bf652959467c8cee83 100644 (file)
--- a/src/flash/flash.h
+++ b/src/flash/flash.h
@@ -29,7 +29,7 @@
 #include "target.h"
 #include "log.h"
 
-struct image_s;
+struct image;
 
 #define FLASH_MAX_ERROR_STR    (128)
 
@@ -286,7 +286,7 @@ int flash_erase_address_range(struct target_s *target,
  * @returns ERROR_OK if successful; otherwise, an error code.
  */
 int flash_write(struct target_s *target,
-               struct image_s *image, uint32_t *written, int erase);
+               struct image *image, uint32_t *written, int erase);
 /**
  * Forces targets to re-examine their erase/protection state.
  * This routine must be called when the system may modify the status.

diff --git a/src/flash/lpc2900.c b/src/flash/lpc2900.c
index 08879077b7f52de36de29676144ac71728e655a2..5b6a5be4dde01d2933c301d5c5a17a33958fb154 100644 (file)
--- a/src/flash/lpc2900.c
+++ b/src/flash/lpc2900.c
@@ -718,7 +718,7 @@ COMMAND_HANDLER(lpc2900_handle_write_custom_command)
        }
 
        /* The image will always start at offset 0 */
-       image_t image;
+       struct image image;
        image.base_address_set = 1;
        image.base_address = 0;
        image.start_address_set = 0;

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 0bdb3a0c2154b0fde9da720f0e815b7d4f9b7a23..732f68be96b3d05796206ff52fa08c6ef3abc1d5 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -1899,7 +1899,7 @@ int gdb_v_packet(struct connection *connection, target_t *target, char *packet,
                /* create a new image if there isn't already one */
                if (gdb_connection->vflash_image == NULL)
                {
-                       gdb_connection->vflash_image = malloc(sizeof(image_t));
+                       gdb_connection->vflash_image = malloc(sizeof(struct image));
                        image_open(gdb_connection->vflash_image, "", "build");
                }
 

diff --git a/src/server/gdb_server.h b/src/server/gdb_server.h
index ee9063b4f288fd3d23fc7943081893474a6b6f83..d3c5f67e9c5a97ebc8bddb152cd7f0cf0d4b3685 100644 (file)
--- a/src/server/gdb_server.h
+++ b/src/server/gdb_server.h
@@ -28,7 +28,7 @@
 
 #include "target.h"
 
-struct image_s;
+struct image;
 
 #define GDB_BUFFER_SIZE        16384
 
@@ -39,7 +39,7 @@ struct gdb_connection
        int buf_cnt;
        int ctrl_c;
        enum target_state frontend_state;
-       struct image_s *vflash_image;
+       struct image *vflash_image;
        int closed;
        int busy;
        int noack_mode;

diff --git a/src/target/etm.c b/src/target/etm.c
index 751ea421ad5993458d9e295443c285c2a1f56b93..667eb5bd1db9b40ff07f737b5fe3b0869324fcfd 100644 (file)
--- a/src/target/etm.c
+++ b/src/target/etm.c
@@ -1761,7 +1761,7 @@ COMMAND_HANDLER(handle_etm_image_command)
                command_print(cmd_ctx, "previously loaded image found and closed");
        }
 
-       etm_ctx->image = malloc(sizeof(image_t));
+       etm_ctx->image = malloc(sizeof(struct image));
        etm_ctx->image->base_address_set = 0;
        etm_ctx->image->start_address_set = 0;
 

diff --git a/src/target/etm.h b/src/target/etm.h
index 3de54eef2a2f9abec1c9065e9ea7833acbf7c62d..531206cc635f338e7b5136b53c74cb3b10d90960 100644 (file)
--- a/src/target/etm.h
+++ b/src/target/etm.h
@@ -26,7 +26,7 @@
 #include "trace.h"
 #include "arm_jtag.h"
 
-struct image_s;
+struct image;
 
 /* ETM registers (JTAG protocol) */
 enum
@@ -165,7 +165,7 @@ struct etm_context
        etm_portmode_t portmode;        /* normal, multiplexed or demultiplexed */
        etmv1_tracemode_t tracemode;    /* type of info trace contains */
        int /*armv4_5_state_t*/ core_state;     /* current core state */
-       struct image_s *image;          /* source for target opcodes */
+       struct image *image;            /* source for target opcodes */
        uint32_t pipe_index;            /* current trace cycle */
        uint32_t data_index;            /* cycle holding next data packet */
        bool data_half;                 /* port half on a 16 bit port */

diff --git a/src/target/image.c b/src/target/image.c
index 27d8eca5e6ff5f2bf860344cf700d9b0b92c36b2..55237f87455b557383782369fc5bf560967b2733 100644 (file)
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -44,7 +44,7 @@
        ((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;
@@ -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,7 +147,7 @@ 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(struct image *image)
 {
        struct image_ihex *ihex = image->type_private;
        struct fileio *fileio = &ihex->fileio;
@@ -158,7 +158,7 @@ static int image_ihex_buffer_complete(image_t *image)
 
        /* 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 image_section section[IMAGE_MAX_SECTIONS];
+       struct imageection section[IMAGE_MAX_SECTIONS];
 
        ihex->buffer = malloc(fileio->size >> 1);
        cooked_bytes = 0x0;
@@ -232,7 +232,7 @@ static int image_ihex_buffer_complete(image_t *image)
                        image->num_sections++;
 
                        /* copy section information */
-                       image->sections = malloc(sizeof(struct image_section) * 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,7 +357,7 @@ static int image_ihex_buffer_complete(image_t *image)
        return ERROR_IMAGE_FORMAT_ERROR;
 }
 
-static int image_elf_read_headers(image_t *image)
+static int image_elf_read_headers(struct image *image)
 {
        struct image_elf *elf = image->type_private;
        uint32_t read_bytes;
@@ -439,7 +439,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(struct image_section));
+       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,7 +458,7 @@ 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, uint32_t *size_read)
 {
        struct image_elf *elf = image->type_private;
        Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
@@ -499,7 +499,7 @@ 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(struct image *image)
 {
        struct image_mot *mot = image->type_private;
        struct fileio *fileio = &mot->fileio;
@@ -510,7 +510,7 @@ static int image_mot_buffer_complete(image_t *image)
 
        /* 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 image_section section[IMAGE_MAX_SECTIONS];
+       struct imageection section[IMAGE_MAX_SECTIONS];
 
        mot->buffer = malloc(fileio->size >> 1);
        cooked_bytes = 0x0;
@@ -635,7 +635,7 @@ static int image_mot_buffer_complete(image_t *image)
                        image->num_sections++;
 
                        /* copy section information */
-                       image->sections = malloc(sizeof(struct image_section) * 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 +669,7 @@ 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)
+int image_open(struct image *image, const char *url, const char *type_string)
 {
        int retval = ERROR_OK;
 
@@ -690,7 +690,7 @@ int image_open(image_t *image, const char *url, const char *type_string)
                }
 
                image->num_sections = 1;
-               image->sections = malloc(sizeof(struct image_section));
+               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;
@@ -743,7 +743,7 @@ int image_open(image_t *image, const char *url, const char *type_string)
                struct image_memory *image_memory;
 
                image->num_sections = 1;
-               image->sections = malloc(sizeof(struct image_section));
+               image->sections = malloc(sizeof(struct imageection));
                image->sections[0].base_address = 0x0;
                image->sections[0].size = 0xffffffff;
                image->sections[0].flags = 0;
@@ -797,7 +797,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, uint32_t *size_read)
 {
        int retval;
 
@@ -897,9 +897,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)
 {
-       struct image_section *section;
+       struct imageection *section;
 
        /* only image builder supports adding sections */
        if (image->type != IMAGE_BUILDER)
@@ -923,7 +923,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(struct image_section) * 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,7 +934,7 @@ 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)
        {

diff --git a/src/target/image.h b/src/target/image.h
index 0180420ccaa08ac086a1740774a395077f2e47ac..55f0ea29cd56960a7c2f798e7ea4f8282cb65b02 100644 (file)
--- a/src/target/image.h
+++ b/src/target/image.h
@@ -37,7 +37,7 @@
 
 #define IMAGE_MEMORY_CACHE_SIZE                (2048)
 
-typedef enum image_type
+enum image_type
 {
        IMAGE_BINARY,   /* plain binary */
        IMAGE_IHEX,             /* intel hex-record format */
@@ -45,9 +45,9 @@ typedef enum image_type
        IMAGE_ELF,              /* ELF binary */
        IMAGE_SRECORD,  /* motorola s19 */
        IMAGE_BUILDER,  /* when building a new image */
-} image_type_t;
+};
 
-struct image_section
+struct imageection
 {
        uint32_t base_address;
        uint32_t size;
@@ -55,17 +55,17 @@ struct image_section
        void *private;          /* private data */
 };
 
-typedef struct image_s
+struct image
 {
-       image_type_t type;              /* image type (plain, ihex, ...) */
+       enum image_type type;           /* image type (plain, ihex, ...) */
        void *type_private;             /* type private data */
        int num_sections;               /* number of sections contained in the image */
-       struct image_section *sections; /* array of sections */
+       struct imageection *sections;   /* array of sections */
        int base_address_set;   /* whether the image has a base address set (for relocation purposes) */
        int base_address;               /* base address, if one is set */
        int start_address_set;  /* whether the image has a start address (entry point) associated */
        uint32_t start_address;         /* start address, if one is set */
-} image_t;
+};
 
 struct image_binary
 {
@@ -100,12 +100,12 @@ struct image_mot
        uint8_t *buffer;
 };
 
-int image_open(image_t *image, const char *url, const char *type_string);
-int image_read_section(image_t *image, int section, uint32_t offset,
+int image_open(struct image *image, const char *url, const char *type_string);
+int image_read_section(struct image *image, int section, uint32_t offset,
                uint32_t size, uint8_t *buffer, uint32_t *size_read);
-void image_close(image_t *image);
+void image_close(struct image *image);
 
-int image_add_section(image_t *image, uint32_t base, uint32_t size,
+int image_add_section(struct image *image, uint32_t base, uint32_t size,
                int flags, uint8_t *data);
 
 int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes,

diff --git a/src/target/target.c b/src/target/target.c
index 68172f1b2d90db430371605f7c0647f6e331ddff..df8496f576333cc14899b6703a7253437173a3af 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -2363,7 +2363,7 @@ COMMAND_HANDLER(handle_mw_command)
 
 }
 
-static COMMAND_HELPER(parse_load_image_command_args, image_t *image,
+static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
                uint32_t *min_address, uint32_t *max_address)
 {
        if (argc < 1 || argc > 5)
@@ -2408,7 +2408,7 @@ COMMAND_HANDLER(handle_load_image_command)
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
        int i;
-       image_t image;
+       struct image image;
 
        int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
                        &image, &min_address, &max_address);
@@ -2564,7 +2564,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
        uint32_t checksum = 0;
        uint32_t mem_checksum = 0;
 
-       image_t image;
+       struct image image;
 
        target_t *target = get_current_target(cmd_ctx);
 
@@ -4545,7 +4545,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
        uint32_t max_address = 0xffffffff;
        int i;
 
-       image_t image;
+       struct image image;
 
        int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
                        &image, &min_address, &max_address);

diff --git a/src/target/xscale.c b/src/target/xscale.c
index 1e0ea775305acc5e5c0c8e0ddda33e56fd035372..fb265eaf69f1f3fc0ea04188a7a4a2a5b0509f7e 100644 (file)
--- a/src/target/xscale.c
+++ b/src/target/xscale.c
@@ -3390,7 +3390,7 @@ COMMAND_HANDLER(xscale_handle_trace_image_command)
                command_print(cmd_ctx, "previously loaded image found and closed");
        }
 
-       xscale->trace.image = malloc(sizeof(image_t));
+       xscale->trace.image = malloc(sizeof(struct image));
        xscale->trace.image->base_address_set = 0;
        xscale->trace.image->start_address_set = 0;
 

diff --git a/src/target/xscale.h b/src/target/xscale.h
index 53bf4721c84c52b85bef1d72f68ed622f360938c..9f25327ff9c815d5067e52fb6d6679a79639644a 100644 (file)
--- a/src/target/xscale.h
+++ b/src/target/xscale.h
@@ -69,7 +69,7 @@ struct xscale_trace_data
 struct xscale_trace
 {
        trace_status_t capture_status;  /* current state of capture run */
-       struct image_s *image;                                  /* source for target opcodes */
+       struct image *image;                                    /* source for target opcodes */
        struct xscale_trace_data *data;         /* linked list of collected trace data */
        int buffer_enabled;                             /* whether trace buffer is enabled */
        int buffer_fill;                                /* maximum number of trace runs to read (-1 for wrap-around) */