* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
/* Parts of target interface that deal with accessing memory and memory-like
|
|
|
|
objects.
|
|
|
|
|
2011-01-01 16:34:07 +01:00
|
|
|
Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
|
|
|
|
Free Software Foundation, Inc.
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2007-08-23 20:08:50 +02:00
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "vec.h"
|
|
|
|
#include "target.h"
|
|
|
|
#include "memory-map.h"
|
|
|
|
|
|
|
|
#include "gdb_assert.h"
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
|
|
|
static int
|
|
|
|
compare_block_starting_address (const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct memory_write_request *a_req = a;
|
|
|
|
const struct memory_write_request *b_req = b;
|
|
|
|
|
|
|
|
if (a_req->begin < b_req->begin)
|
|
|
|
return -1;
|
|
|
|
else if (a_req->begin == b_req->begin)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Adds to RESULT all memory write requests from BLOCK that are
|
|
|
|
in [BEGIN, END) range.
|
|
|
|
|
|
|
|
If any memory request is only partially in the specified range,
|
|
|
|
that part of the memory request will be added. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
claim_memory (VEC(memory_write_request_s) *blocks,
|
|
|
|
VEC(memory_write_request_s) **result,
|
|
|
|
ULONGEST begin,
|
|
|
|
ULONGEST end)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
ULONGEST claimed_begin;
|
|
|
|
ULONGEST claimed_end;
|
|
|
|
struct memory_write_request *r;
|
|
|
|
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, blocks, i, r); ++i)
|
|
|
|
{
|
|
|
|
/* If the request doesn't overlap [BEGIN, END), skip it. We
|
|
|
|
must handle END == 0 meaning the top of memory; we don't yet
|
|
|
|
check for R->end == 0, which would also mean the top of
|
|
|
|
memory, but there's an assertion in
|
|
|
|
target_write_memory_blocks which checks for that. */
|
|
|
|
|
|
|
|
if (begin >= r->end)
|
|
|
|
continue;
|
|
|
|
if (end != 0 && end <= r->begin)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
claimed_begin = max (begin, r->begin);
|
|
|
|
if (end == 0)
|
|
|
|
claimed_end = r->end;
|
|
|
|
else
|
|
|
|
claimed_end = min (end, r->end);
|
|
|
|
|
|
|
|
if (claimed_begin == r->begin && claimed_end == r->end)
|
|
|
|
VEC_safe_push (memory_write_request_s, *result, r);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct memory_write_request *n =
|
|
|
|
VEC_safe_push (memory_write_request_s, *result, NULL);
|
2010-05-17 03:15:20 +02:00
|
|
|
|
2007-10-24 22:14:58 +02:00
|
|
|
*n = *r;
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
n->begin = claimed_begin;
|
|
|
|
n->end = claimed_end;
|
2007-10-24 22:14:58 +02:00
|
|
|
n->data += claimed_begin - r->begin;
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given a vector of struct memory_write_request objects in BLOCKS,
|
|
|
|
add memory requests for flash memory into FLASH_BLOCKS, and for
|
|
|
|
regular memory to REGULAR_BLOCKS. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks,
|
|
|
|
VEC(memory_write_request_s) **regular_blocks,
|
|
|
|
VEC(memory_write_request_s) **flash_blocks)
|
|
|
|
{
|
|
|
|
struct mem_region *region;
|
|
|
|
CORE_ADDR cur_address;
|
|
|
|
|
|
|
|
/* This implementation runs in O(length(regions)*length(blocks)) time.
|
|
|
|
However, in most cases the number of blocks will be small, so this does
|
|
|
|
not matter.
|
|
|
|
|
|
|
|
Note also that it's extremely unlikely that a memory write request
|
|
|
|
will span more than one memory region, however for safety we handle
|
|
|
|
such situations. */
|
|
|
|
|
|
|
|
cur_address = 0;
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
VEC(memory_write_request_s) **r;
|
|
|
|
|
2010-05-17 03:15:20 +02:00
|
|
|
region = lookup_mem_region (cur_address);
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks;
|
|
|
|
cur_address = region->hi;
|
|
|
|
claim_memory (blocks, r, region->lo, region->hi);
|
|
|
|
|
|
|
|
if (cur_address == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN
|
|
|
|
to the start of the flash block containing the address. Similarly,
|
|
|
|
if END is non-NULL *END will be set to the address one past the end
|
|
|
|
of the block containing the address. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end)
|
|
|
|
{
|
|
|
|
struct mem_region *region;
|
|
|
|
unsigned blocksize;
|
|
|
|
|
|
|
|
region = lookup_mem_region (address);
|
|
|
|
gdb_assert (region->attrib.mode == MEM_FLASH);
|
|
|
|
blocksize = region->attrib.blocksize;
|
|
|
|
if (begin)
|
|
|
|
*begin = address / blocksize * blocksize;
|
|
|
|
if (end)
|
|
|
|
*end = (address + blocksize - 1) / blocksize * blocksize;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given the list of memory requests to be WRITTEN, this function
|
|
|
|
returns write requests covering each group of flash blocks which must
|
|
|
|
be erased. */
|
|
|
|
|
|
|
|
static VEC(memory_write_request_s) *
|
|
|
|
blocks_to_erase (VEC(memory_write_request_s) *written)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
struct memory_write_request *ptr;
|
|
|
|
|
|
|
|
VEC(memory_write_request_s) *result = NULL;
|
|
|
|
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i)
|
|
|
|
{
|
|
|
|
CORE_ADDR begin, end;
|
|
|
|
|
|
|
|
block_boundaries (ptr->begin, &begin, 0);
|
2007-06-07 16:24:15 +02:00
|
|
|
block_boundaries (ptr->end - 1, 0, &end);
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
|
|
|
|
if (!VEC_empty (memory_write_request_s, result)
|
|
|
|
&& VEC_last (memory_write_request_s, result)->end >= begin)
|
|
|
|
{
|
|
|
|
VEC_last (memory_write_request_s, result)->end = end;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct memory_write_request *n =
|
|
|
|
VEC_safe_push (memory_write_request_s, result, NULL);
|
2010-05-17 03:15:20 +02:00
|
|
|
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
memset (n, 0, sizeof (struct memory_write_request));
|
|
|
|
n->begin = begin;
|
|
|
|
n->end = end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given ERASED_BLOCKS, a list of blocks that will be erased with
|
|
|
|
flash erase commands, and WRITTEN_BLOCKS, the list of memory
|
|
|
|
addresses that will be written, compute the set of memory addresses
|
|
|
|
that will be erased but not rewritten (e.g. padding within a block
|
|
|
|
which is only partially filled by "load"). */
|
|
|
|
|
|
|
|
static VEC(memory_write_request_s) *
|
|
|
|
compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
|
|
|
|
VEC(memory_write_request_s) *written_blocks)
|
|
|
|
{
|
|
|
|
VEC(memory_write_request_s) *result = NULL;
|
|
|
|
|
|
|
|
unsigned i, j;
|
|
|
|
unsigned je = VEC_length (memory_write_request_s, written_blocks);
|
|
|
|
struct memory_write_request *erased_p;
|
|
|
|
|
|
|
|
/* Look at each erased memory_write_request in turn, and
|
|
|
|
see what part of it is subsequently written to.
|
|
|
|
|
|
|
|
This implementation is O(length(erased) * length(written)). If
|
|
|
|
the lists are sorted at this point it could be rewritten more
|
|
|
|
efficiently, but the complexity is not generally worthwhile. */
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
VEC_iterate (memory_write_request_s, erased_blocks, i, erased_p);
|
|
|
|
++i)
|
|
|
|
{
|
|
|
|
/* Make a deep copy -- it will be modified inside the loop, but
|
|
|
|
we don't want to modify original vector. */
|
|
|
|
struct memory_write_request erased = *erased_p;
|
|
|
|
|
|
|
|
for (j = 0; j != je;)
|
|
|
|
{
|
|
|
|
struct memory_write_request *written
|
|
|
|
= VEC_index (memory_write_request_s,
|
|
|
|
written_blocks, j);
|
|
|
|
|
|
|
|
/* Now try various cases. */
|
|
|
|
|
|
|
|
/* If WRITTEN is fully to the left of ERASED, check the next
|
|
|
|
written memory_write_request. */
|
|
|
|
if (written->end <= erased.begin)
|
|
|
|
{
|
|
|
|
++j;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If WRITTEN is fully to the right of ERASED, then ERASED
|
|
|
|
is not written at all. WRITTEN might affect other
|
|
|
|
blocks. */
|
|
|
|
if (written->begin >= erased.end)
|
|
|
|
{
|
|
|
|
VEC_safe_push (memory_write_request_s, result, &erased);
|
|
|
|
goto next_erased;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If all of ERASED is completely written, we can move on to
|
|
|
|
the next erased region. */
|
|
|
|
if (written->begin <= erased.begin
|
|
|
|
&& written->end >= erased.end)
|
|
|
|
{
|
|
|
|
goto next_erased;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is an unwritten part at the beginning of ERASED,
|
|
|
|
then we should record that part and try this inner loop
|
|
|
|
again for the remainder. */
|
|
|
|
if (written->begin > erased.begin)
|
|
|
|
{
|
|
|
|
struct memory_write_request *n =
|
|
|
|
VEC_safe_push (memory_write_request_s, result, NULL);
|
2010-05-17 03:15:20 +02:00
|
|
|
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
memset (n, 0, sizeof (struct memory_write_request));
|
|
|
|
n->begin = erased.begin;
|
|
|
|
n->end = written->begin;
|
|
|
|
erased.begin = written->begin;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is an unwritten part at the end of ERASED, we
|
|
|
|
forget about the part that was written to and wait to see
|
|
|
|
if the next write request writes more of ERASED. We can't
|
|
|
|
push it yet. */
|
|
|
|
if (written->end < erased.end)
|
|
|
|
{
|
|
|
|
erased.begin = written->end;
|
|
|
|
++j;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we ran out of write requests without doing anything about
|
|
|
|
ERASED, then that means it's really erased. */
|
|
|
|
VEC_safe_push (memory_write_request_s, result, &erased);
|
|
|
|
|
|
|
|
next_erased:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cleanup_request_data (void *p)
|
|
|
|
{
|
|
|
|
VEC(memory_write_request_s) **v = p;
|
|
|
|
struct memory_write_request *r;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, *v, i, r); ++i)
|
|
|
|
xfree (r->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cleanup_write_requests_vector (void *p)
|
|
|
|
{
|
|
|
|
VEC(memory_write_request_s) **v = p;
|
2010-05-17 03:15:20 +02:00
|
|
|
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
VEC_free (memory_write_request_s, *v);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
target_write_memory_blocks (VEC(memory_write_request_s) *requests,
|
|
|
|
enum flash_preserve_mode preserve_flash_p,
|
|
|
|
void (*progress_cb) (ULONGEST, void *))
|
|
|
|
{
|
|
|
|
struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
|
|
|
|
VEC(memory_write_request_s) *blocks = VEC_copy (memory_write_request_s,
|
|
|
|
requests);
|
|
|
|
unsigned i;
|
|
|
|
int err = 0;
|
|
|
|
struct memory_write_request *r;
|
|
|
|
VEC(memory_write_request_s) *regular = NULL;
|
|
|
|
VEC(memory_write_request_s) *flash = NULL;
|
|
|
|
VEC(memory_write_request_s) *erased, *garbled;
|
|
|
|
|
|
|
|
/* END == 0 would represent wraparound: a write to the very last
|
|
|
|
byte of the address space. This file was not written with that
|
|
|
|
possibility in mind. This is fixable, but a lot of work for a
|
|
|
|
rare problem; so for now, fail noisily here instead of obscurely
|
|
|
|
later. */
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, requests, i, r); ++i)
|
|
|
|
gdb_assert (r->end != 0);
|
|
|
|
|
|
|
|
make_cleanup (cleanup_write_requests_vector, &blocks);
|
|
|
|
|
|
|
|
/* Sort the blocks by their start address. */
|
|
|
|
qsort (VEC_address (memory_write_request_s, blocks),
|
|
|
|
VEC_length (memory_write_request_s, blocks),
|
|
|
|
sizeof (struct memory_write_request), compare_block_starting_address);
|
|
|
|
|
|
|
|
/* Split blocks into list of regular memory blocks,
|
2011-01-11 22:53:25 +01:00
|
|
|
and list of flash memory blocks. */
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
make_cleanup (cleanup_write_requests_vector, ®ular);
|
|
|
|
make_cleanup (cleanup_write_requests_vector, &flash);
|
|
|
|
split_regular_and_flash_blocks (blocks, ®ular, &flash);
|
|
|
|
|
|
|
|
/* If a variable is added to forbid flash write, even during "load",
|
|
|
|
it should be checked here. Similarly, if this function is used
|
|
|
|
for other situations besides "load" in which writing to flash
|
|
|
|
is undesirable, that should be checked here. */
|
|
|
|
|
|
|
|
/* Find flash blocks to erase. */
|
|
|
|
erased = blocks_to_erase (flash);
|
|
|
|
make_cleanup (cleanup_write_requests_vector, &erased);
|
|
|
|
|
|
|
|
/* Find what flash regions will be erased, and not overwritten; then
|
|
|
|
either preserve or discard the old contents. */
|
|
|
|
garbled = compute_garbled_blocks (erased, flash);
|
|
|
|
make_cleanup (cleanup_request_data, &garbled);
|
|
|
|
make_cleanup (cleanup_write_requests_vector, &garbled);
|
|
|
|
|
|
|
|
if (!VEC_empty (memory_write_request_s, garbled))
|
|
|
|
{
|
|
|
|
if (preserve_flash_p == flash_preserve)
|
|
|
|
{
|
|
|
|
struct memory_write_request *r;
|
|
|
|
|
|
|
|
/* Read in regions that must be preserved and add them to
|
|
|
|
the list of blocks we read. */
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, garbled, i, r); ++i)
|
|
|
|
{
|
|
|
|
gdb_assert (r->data == NULL);
|
|
|
|
r->data = xmalloc (r->end - r->begin);
|
|
|
|
err = target_read_memory (r->begin, r->data, r->end - r->begin);
|
|
|
|
if (err != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
VEC_safe_push (memory_write_request_s, flash, r);
|
|
|
|
}
|
|
|
|
|
|
|
|
qsort (VEC_address (memory_write_request_s, flash),
|
|
|
|
VEC_length (memory_write_request_s, flash),
|
2011-01-05 23:22:53 +01:00
|
|
|
sizeof (struct memory_write_request),
|
|
|
|
compare_block_starting_address);
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We could coalesce adjacent memory blocks here, to reduce the
|
|
|
|
number of write requests for small sections. However, we would
|
|
|
|
have to reallocate and copy the data pointers, which could be
|
|
|
|
large; large sections are more common in loadable objects than
|
|
|
|
large numbers of small sections (although the reverse can be true
|
|
|
|
in object files). So, we issue at least one write request per
|
|
|
|
passed struct memory_write_request. The remote stub will still
|
|
|
|
have the opportunity to batch flash requests. */
|
|
|
|
|
|
|
|
/* Write regular blocks. */
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i)
|
|
|
|
{
|
|
|
|
LONGEST len;
|
|
|
|
|
* target.h (struct target_ops): Make to_has_all_memory,
to_has_memory, to_has_stack, to_has_registers and to_has_execution
methods instead of variables.
(target_has_all_memory_1, target_has_memory_1, target_has_stack_1)
(target_has_registers_1, target_has_execution_1): Declare
functions.
(target_has_all_memory): Rewrite to call target_has_all_memory_1.
(target_has_memory): Rewrite to call target_has_memory_1.
(target_has_stack): Rewrite to call target_has_all_stack_1.
(target_has_registers): Rewrite to call target_has_registers_1.
(target_has_execution): Rewrite to call target_has_execution_1.
(default_child_has_all_memory, default_child_has_memory)
(default_child_has_stack, default_child_has_registers)
(default_child_has_execution): Declare.
(target_mark_running, target_mark_exited): Delete declarations.
* target.c (default_child_has_all_memory,
default_child_has_memory, default_child_has_stack,
default_child_has_registers, default_child_has_execution): New.
(target_has_all_memory_1, target_has_memory_1, target_has_stack_1,
target_has_registers_1, target_has_execution_1): New.
(add_target): Default the to_has_all_memory, to_has_all_memory,
to_has_memory, to_has_stack, to_has_registers and to_has_execution
callbacks to return 0.
(update_current_target): Do not inherit to_has_all_memory,
to_has_memory, to_has_stack, to_has_registers or to_has_execution.
(target_mark_running, target_mark_exited): Delete.
(memory_xfer_partial): Adjust.
(target_read_memory, target_write_memory, target_search_memory):
Dispatch to the the top-most target, not the flattened
current_target.
(target_info): Adjust.
(init_dummy_target): Install return_zero as callback for
to_has_all_memory, to_has_memory, to_has_stack, to_has_registers,
to_has_execution.
(set_maintenance_target_async_permitted): Use have_live_inferiors
instead of target_has_execution.
* target-memory.c (target_write_memory_blocks): Dispatch memory
writes to the the top-most target, not the flattened
current_target.
* breakpoint.c (insert_breakpoints): Don't check for
target_has_execution here.
(update_global_location_list): Check if there are live inferiors
to debug instead of target_has_execution.
* infcmd.c (kill_command, detach_command): Check if there are
inferiors instead of target_has_execution.
* inferior.h (have_live_inferiors): Declare.
* inferior.c (have_live_inferiors): New.
* infrun.c (normal_stop): Don't check for target_has_execution to
finish the thread states.
* thread.c (is_thread_state, is_stopped, is_exited, is_running)
(any_running, is_executing): Remove checks for
target_has_execution.
* top.c (kill_or_detach): Don't try to kill core inferiors.
(quit_target): Don't check for target_has_execution.
* corelow.c (core_has_memory, core_has_stack, core_has_registers):
New.
(init_core_ops): Install core_has_memory, core_has_stack and
core_has_registers.
* exec.c (exec_has_memory): New.
(init_exec_ops): Install exec_has_memory.
* remote.c (remote_add_inferior): Don't call target_mark_running.
(remote_start_remote): Don't call target_mark_exited or call
target_mark_running.
(remote_open_1): Use have_inferiors instead of
target_has_execution. Don't use target_mark_exited.
(init_remote_ops): Install deafult_child_has_all_memory,
default_child_has_memory, default_child_has_stack,
default_child_has_registers, default_child_has_execution.
* bsd-kvm.c (bsd_kvm_return_one): New.
(bsd_kvm_add_target): Register bsd_kvm_return_one as
to_has_memory, to_has_stack and to_has_registers callbacks.
* remote-m32r-sdi.c (m32r_return_one): New.
(init_m32r_ops): Register it.
* inf-child.c (inf_child_target): Adjust to register
default_child_has_all_memory, default_child_has_memory,
default_child_has_stack, default_child_has_registers,
default_child_has_execution callbacks.
* gnu-nat.c (init_gnu_ops): Likewise.
* go32-nat.c (init_go32_ops): Likewise.
* hpux-thread.c (init_hpux_thread_ops): Likewise.
* monitor.c (init_base_monitor_ops): Likewise.
* nto-procfs.c (init_procfs_ops): Likewise.
* remote-mips.c (_initialize_remote_mips): Likewise.
* windows-nat.c (init_windows_ops): Likewise.
* remote-sim.c (gdbsim_create_inferior): Don't use
target_mark_running or target_mark_exited.
(gdbsim_mourn_inferior): Don't call target_mark_exited.
(init_gdbsim_ops): Adjust to register
default_child_has_all_memory, default_child_has_memory,
default_child_has_stack, default_child_has_registers,
default_child_has_execution callbacks.
* linux-nat.c (linux_nat_xfer_partial): If reading memory, and
there's no inferior selected, defer to a lower stratum.
2009-06-07 18:46:48 +02:00
|
|
|
len = target_write_with_progress (current_target.beneath,
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
TARGET_OBJECT_MEMORY, NULL,
|
|
|
|
r->data, r->begin, r->end - r->begin,
|
|
|
|
progress_cb, r->baton);
|
|
|
|
if (len < (LONGEST) (r->end - r->begin))
|
|
|
|
{
|
|
|
|
/* Call error? */
|
|
|
|
err = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!VEC_empty (memory_write_request_s, erased))
|
|
|
|
{
|
|
|
|
/* Erase all pages. */
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, erased, i, r); ++i)
|
|
|
|
target_flash_erase (r->begin, r->end - r->begin);
|
|
|
|
|
|
|
|
/* Write flash data. */
|
|
|
|
for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i)
|
|
|
|
{
|
|
|
|
LONGEST len;
|
|
|
|
|
|
|
|
len = target_write_with_progress (¤t_target,
|
|
|
|
TARGET_OBJECT_FLASH, NULL,
|
2011-01-05 23:22:53 +01:00
|
|
|
r->data, r->begin,
|
|
|
|
r->end - r->begin,
|
* Makefile.in (SFILES): Add target-memory.c.
(COMMON_OBS): Add target-memory.o.
* memattr.c (lookup_mem_region): Adjust handling for
the top of memory. Improve comments.
* remote.c (packet_check_result): New function, split out
from packet_ok. Recognize "E." as an error prefix.
(packet_ok): Use it.
(remote_write_bytes_aux): New function, renamed from
remote_write_bytes. Take packet header, packet format,
and length flag as arguments.
(remote_write_bytes): Rewrite to use remote_write_bytes_aux.
(remote_send_printf, restore_remote_timeout)
(remote_flash_timeout, remote_flash_erase, remote_flash_write)
(remote_flash_done): New.
(remote_xfer_partial): Handle flash writes.
(init_remote_ops, init_remote_async_ops): Set to_flash_erase
and to_flash_done.
* symfile.c (struct load_section_data): Include a pointer to
the cumulative stats and a request queue. Move most members
to other types.
(struct load_progress_data, struct load_progress_section_data): New
types.
(load_progress): Handle a NULL baton and zero bytes. Update for
type changes.
(load_section_callback): Create memory write requests instead of
writing to memory. Don't print the progress message here.
(clear_memory_write_data): New function.
(generic_load): Use target_write_memory_blocks.
* target-memory.c: New file.
* target.c (update_current_target): Mention new uninherited methods.
(memory_xfer_partial): Issue an error for flash writes.
(target_flash_erase, target_flash_done): New functions.
(target_write_with_progress): Call the progress callback at the
start also.
* target.h (enum target_object): Add TARGET_OBJECT_FLASH.
(target_write_with_progress): Update comment.
(struct target_ops): Add to_flash_erase and to_flash_done.
(target_flash_erase, target_flash_done, struct memory_write_request)
(memory_write_request_s, enum flash_preserve_mode)
(target_write_memory_blocks): New, including a vector type
for memory_write_request_s.
2006-09-21 16:00:53 +02:00
|
|
|
progress_cb, r->baton);
|
|
|
|
if (len < (LONGEST) (r->end - r->begin))
|
|
|
|
error (_("Error writing data to flash"));
|
|
|
|
}
|
|
|
|
|
|
|
|
target_flash_done ();
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
do_cleanups (back_to);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|