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

1 files changed, 437 insertions, 0 deletions

diff --git a/gdb/target-memory.c b/gdb/target-memory.c
new file mode 100644
index 0000000000..64c16e1ac0
--- /dev/null
+++ b/gdb/target-memory.c
@@ -0,0 +1,437 @@
+/* Parts of target interface that deal with accessing memory and memory-like
+   objects.
+
+   Copyright (C) 2006
+   Free Software Foundation, Inc.
+
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (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
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#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);
+	  memset (n, 0, sizeof (struct memory_write_request));
+	  n->begin = claimed_begin;
+	  n->end = claimed_end;
+	  n->data = r->data + (claimed_begin - r->begin);
+	}
+    }
+}
+
+/* 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;
+      region = lookup_mem_region (cur_address);
+
+      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);
+      block_boundaries (ptr->end, 0, &end);
+
+      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);
+	  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);
+	      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;
+  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,
+     and list of flash memory blocks. */
+  make_cleanup (cleanup_write_requests_vector, &regular);
+  make_cleanup (cleanup_write_requests_vector, &flash);
+  split_regular_and_flash_blocks (blocks, &regular, &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),
+		 sizeof (struct memory_write_request), compare_block_starting_address);
+	}
+    }
+
+  /* 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;
+
+      len = target_write_with_progress (&current_target,
+					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 (&current_target,
+					    TARGET_OBJECT_FLASH, NULL,
+					    r->data, r->begin, r->end - r->begin,
+					    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;
+}