interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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.
This commit is contained in:
Zachary T Welch 2009-11-13 09:46:21 -08:00
parent af949b2531
commit dfecfd5fd4
13 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/flash/ecos.c
View File

@ -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;

8
src/flash/flash.c
View File

@ -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);
}

4
src/flash/flash.h
View File

@ -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.

2
src/flash/lpc2900.c
View File

@ -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;

2
src/server/gdb_server.c
View File

@ -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");
}

4
src/server/gdb_server.h
View File

@ -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;

2
src/target/etm.c
View File

@ -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;

4
src/target/etm.h
View File

@ -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 */

38
src/target/image.c
View File

@ -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)
{

22
src/target/image.h
View File

@ -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,

8
src/target/target.c
View File

@ -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);

2
src/target/xscale.c
View File

@ -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;

2
src/target/xscale.h
View File

@ -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) */