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.
13 files changed:
{
uint32_t buf_cnt;
uint32_t image_size;
{
uint32_t buf_cnt;
uint32_t image_size;
image.base_address_set = 0;
image.start_address_set = 0;
image.base_address_set = 0;
image.start_address_set = 0;
#include "image.h"
#include "time_support.h"
#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);
{
target_t *target = get_current_target(cmd_ctx);
{
target_t *target = get_current_target(cmd_ctx);
uint32_t written;
int retval;
uint32_t written;
int retval;
/* write (optional verify) an image to flash memory of the given target */
/* 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 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);
}
{
return flash_write_unlock(target, image, written, erase, false);
}
#include "target.h"
#include "log.h"
#include "target.h"
#include "log.h"
#define FLASH_MAX_ERROR_STR (128)
#define FLASH_MAX_ERROR_STR (128)
* @returns ERROR_OK if successful; otherwise, an error code.
*/
int flash_write(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.
/**
* Forces targets to re-examine their erase/protection state.
* This routine must be called when the system may modify the status.
}
/* The image will always start at offset 0 */
}
/* The image will always start at offset 0 */
image.base_address_set = 1;
image.base_address = 0;
image.start_address_set = 0;
image.base_address_set = 1;
image.base_address = 0;
image.start_address_set = 0;
/* create a new image if there isn't already one */
if (gdb_connection->vflash_image == NULL)
{
/* 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");
}
image_open(gdb_connection->vflash_image, "", "build");
}
#define GDB_BUFFER_SIZE 16384
#define GDB_BUFFER_SIZE 16384
int buf_cnt;
int ctrl_c;
enum target_state frontend_state;
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;
int closed;
int busy;
int noack_mode;
command_print(cmd_ctx, "previously loaded image found and closed");
}
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;
etm_ctx->image->base_address_set = 0;
etm_ctx->image->start_address_set = 0;
#include "trace.h"
#include "arm_jtag.h"
#include "trace.h"
#include "arm_jtag.h"
/* ETM registers (JTAG protocol) */
enum
/* ETM registers (JTAG protocol) */
enum
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 */
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 */
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 */
((elf->endianness == ELFDATA2LSB)? \
le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field))
((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;
{
int retval;
struct fileio fileio;
-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)
-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;
{
struct image_ihex *ihex = image->type_private;
struct fileio *fileio = &ihex->fileio;
/* 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 */
/* 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;
ihex->buffer = malloc(fileio->size >> 1);
cooked_bytes = 0x0;
image->num_sections++;
/* copy section information */
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;
for (i = 0; i < image->num_sections; i++)
{
image->sections[i].private = section[i].private;
return ERROR_IMAGE_FORMAT_ERROR;
}
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;
{
struct image_elf *elf = image->type_private;
uint32_t read_bytes;
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 */
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))
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))
-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;
{
struct image_elf *elf = image->type_private;
Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
-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;
{
struct image_mot *mot = image->type_private;
struct fileio *fileio = &mot->fileio;
/* 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 */
/* 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;
mot->buffer = malloc(fileio->size >> 1);
cooked_bytes = 0x0;
image->num_sections++;
/* copy section information */
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;
for (i = 0; i < image->num_sections; i++)
{
image->sections[i].private = section[i].private;
return ERROR_IMAGE_FORMAT_ERROR;
}
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)
}
image->num_sections = 1;
}
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;
image->sections[0].base_address = 0x0;
image->sections[0].size = image_binary->fileio.size;
image->sections[0].flags = 0;
struct image_memory *image_memory;
image->num_sections = 1;
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;
image->sections[0].base_address = 0x0;
image->sections[0].size = 0xffffffff;
image->sections[0].flags = 0;
-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 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)
/* only image builder supports adding sections */
if (image->type != IMAGE_BUILDER)
/* allocate new section */
image->num_sections++;
/* 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;
section = &image->sections[image->num_sections - 1];
section->base_address = base;
section->size = size;
-void image_close(image_t *image)
+void image_close(struct image *image)
{
if (image->type == IMAGE_BINARY)
{
{
if (image->type == IMAGE_BINARY)
{
#define IMAGE_MEMORY_CACHE_SIZE (2048)
#define IMAGE_MEMORY_CACHE_SIZE (2048)
{
IMAGE_BINARY, /* plain binary */
IMAGE_IHEX, /* intel hex-record format */
{
IMAGE_BINARY, /* plain binary */
IMAGE_IHEX, /* intel hex-record format */
IMAGE_ELF, /* ELF binary */
IMAGE_SRECORD, /* motorola s19 */
IMAGE_BUILDER, /* when building a new image */
IMAGE_ELF, /* ELF binary */
IMAGE_SRECORD, /* motorola s19 */
IMAGE_BUILDER, /* when building a new image */
{
uint32_t base_address;
uint32_t size;
{
uint32_t base_address;
uint32_t size;
void *private; /* private data */
};
void *private; /* private data */
};
- 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 */
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 */
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 */
-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);
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,
int flags, uint8_t *data);
int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes,
-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)
uint32_t *min_address, uint32_t *max_address)
{
if (argc < 1 || argc > 5)
uint32_t min_address = 0;
uint32_t max_address = 0xffffffff;
int i;
uint32_t min_address = 0;
uint32_t max_address = 0xffffffff;
int i;
int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
uint32_t checksum = 0;
uint32_t mem_checksum = 0;
uint32_t checksum = 0;
uint32_t mem_checksum = 0;
target_t *target = get_current_target(cmd_ctx);
target_t *target = get_current_target(cmd_ctx);
uint32_t max_address = 0xffffffff;
int i;
uint32_t max_address = 0xffffffff;
int i;
int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
command_print(cmd_ctx, "previously loaded image found and closed");
}
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;
xscale->trace.image->base_address_set = 0;
xscale->trace.image->start_address_set = 0;
struct xscale_trace
{
trace_status_t capture_status; /* current state of capture run */
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) */
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) */
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)