[deliverable/binutils-gdb.git] / gdb / target-memory.c

/* Parts of target interface that deal with accessing memory and memory-like
   objects.

   Copyright (C) 2006-2016 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "vec.h"
#include "target.h"
#include "memory-map.h"

#include "gdb_sys_time.h"

static int
compare_block_starting_address (const void *a, const void *b)
{
  const struct memory_write_request *a_req
    = (const struct memory_write_request *) a;
  const struct memory_write_request *b_req
    = (const struct memory_write_request *) 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);

	  *n = *r;
	  n->begin = claimed_begin;
	  n->end = claimed_end;
	  n->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 - 1, 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 = (VEC(memory_write_request_s) **) 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 = (VEC(memory_write_request_s) **) 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 = (gdb_byte *) 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.beneath,
					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;
}
Commit	Line	Data
a76d924d DJ	1	/* Parts of target interface that deal with accessing memory and memory-like
	2	objects.
	3
618f726f	4	Copyright (C) 2006-2016 Free Software Foundation, Inc.
a76d924d DJ	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
a76d924d DJ	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
a76d924d DJ	20
	21	#include "defs.h"
	22	#include "vec.h"
	23	#include "target.h"
	24	#include "memory-map.h"
	25
438e1e42	26	#include "gdb_sys_time.h"
a76d924d DJ	27
	28	static int
	29	compare_block_starting_address (const void a, const void b)
	30	{
19ba03f4 SM	31	const struct memory_write_request *a_req
	32	= (const struct memory_write_request *) a;
	33	const struct memory_write_request *b_req
	34	= (const struct memory_write_request *) b;
a76d924d DJ	35
	36	if (a_req->begin < b_req->begin)
	37	return -1;
	38	else if (a_req->begin == b_req->begin)
	39	return 0;
	40	else
	41	return 1;
	42	}
	43
	44	/* Adds to RESULT all memory write requests from BLOCK that are
	45	in [BEGIN, END) range.
	46
	47	If any memory request is only partially in the specified range,
	48	that part of the memory request will be added. */
	49
	50	static void
	51	claim_memory (VEC(memory_write_request_s) *blocks,
	52	VEC(memory_write_request_s) **result,
	53	ULONGEST begin,
	54	ULONGEST end)
	55	{
	56	int i;
	57	ULONGEST claimed_begin;
	58	ULONGEST claimed_end;
	59	struct memory_write_request *r;
	60
	61	for (i = 0; VEC_iterate (memory_write_request_s, blocks, i, r); ++i)
	62	{
	63	/* If the request doesn't overlap [BEGIN, END), skip it. We
	64	must handle END == 0 meaning the top of memory; we don't yet
	65	check for R->end == 0, which would also mean the top of
	66	memory, but there's an assertion in
	67	target_write_memory_blocks which checks for that. */
	68
	69	if (begin >= r->end)
	70	continue;
	71	if (end != 0 && end <= r->begin)
	72	continue;
	73
	74	claimed_begin = max (begin, r->begin);
	75	if (end == 0)
	76	claimed_end = r->end;
	77	else
	78	claimed_end = min (end, r->end);
	79
	80	if (claimed_begin == r->begin && claimed_end == r->end)
	81	VEC_safe_push (memory_write_request_s, *result, r);
	82	else
	83	{
	84	struct memory_write_request *n =
	85	VEC_safe_push (memory_write_request_s, *result, NULL);
5d502164	86
24bf05ac	87	n = r;
a76d924d DJ	88	n->begin = claimed_begin;
a76d924d DJ	89	n->end = claimed_end;
24bf05ac	90	n->data += claimed_begin - r->begin;
a76d924d DJ	91	}
	92	}
	93	}
	94
	95	/* Given a vector of struct memory_write_request objects in BLOCKS,
	96	add memory requests for flash memory into FLASH_BLOCKS, and for
	97	regular memory to REGULAR_BLOCKS. */
	98
	99	static void
	100	split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks,
	101	VEC(memory_write_request_s) **regular_blocks,
	102	VEC(memory_write_request_s) **flash_blocks)
	103	{
	104	struct mem_region *region;
	105	CORE_ADDR cur_address;
	106
	107	/* This implementation runs in O(length(regions)*length(blocks)) time.
	108	However, in most cases the number of blocks will be small, so this does
	109	not matter.
	110
	111	Note also that it's extremely unlikely that a memory write request
	112	will span more than one memory region, however for safety we handle
	113	such situations. */
	114
	115	cur_address = 0;
	116	while (1)
	117	{
	118	VEC(memory_write_request_s) **r;
a76d924d	119
5d502164	120	region = lookup_mem_region (cur_address);
a76d924d DJ	121	r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks;
	122	cur_address = region->hi;
	123	claim_memory (blocks, r, region->lo, region->hi);
	124
	125	if (cur_address == 0)
	126	break;
	127	}
	128	}
	129
	130	/* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN
	131	to the start of the flash block containing the address. Similarly,
	132	if END is non-NULL *END will be set to the address one past the end
	133	of the block containing the address. */
	134
	135	static void
	136	block_boundaries (CORE_ADDR address, CORE_ADDR begin, CORE_ADDR end)
	137	{
	138	struct mem_region *region;
	139	unsigned blocksize;
	140
	141	region = lookup_mem_region (address);
	142	gdb_assert (region->attrib.mode == MEM_FLASH);
	143	blocksize = region->attrib.blocksize;
	144	if (begin)
	145	begin = address / blocksize blocksize;
	146	if (end)
	147	end = (address + blocksize - 1) / blocksize blocksize;
	148	}
	149
	150	/* Given the list of memory requests to be WRITTEN, this function
	151	returns write requests covering each group of flash blocks which must
	152	be erased. */
	153
	154	static VEC(memory_write_request_s) *
	155	blocks_to_erase (VEC(memory_write_request_s) *written)
	156	{
	157	unsigned i;
	158	struct memory_write_request *ptr;
	159
	160	VEC(memory_write_request_s) *result = NULL;
	161
	162	for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i)
	163	{
	164	CORE_ADDR begin, end;
	165
	166	block_boundaries (ptr->begin, &begin, 0);
1fc01e03	167	block_boundaries (ptr->end - 1, 0, &end);
a76d924d DJ	168
	169	if (!VEC_empty (memory_write_request_s, result)
	170	&& VEC_last (memory_write_request_s, result)->end >= begin)
	171	{
	172	VEC_last (memory_write_request_s, result)->end = end;
	173	}
	174	else
	175	{
	176	struct memory_write_request *n =
	177	VEC_safe_push (memory_write_request_s, result, NULL);
5d502164	178
a76d924d DJ	179	memset (n, 0, sizeof (struct memory_write_request));
	180	n->begin = begin;
	181	n->end = end;
	182	}
	183	}
	184
	185	return result;
	186	}
	187
	188	/* Given ERASED_BLOCKS, a list of blocks that will be erased with
	189	flash erase commands, and WRITTEN_BLOCKS, the list of memory
	190	addresses that will be written, compute the set of memory addresses
	191	that will be erased but not rewritten (e.g. padding within a block
	192	which is only partially filled by "load"). */
	193
	194	static VEC(memory_write_request_s) *
	195	compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
	196	VEC(memory_write_request_s) *written_blocks)
	197	{
	198	VEC(memory_write_request_s) *result = NULL;
	199
	200	unsigned i, j;
	201	unsigned je = VEC_length (memory_write_request_s, written_blocks);
	202	struct memory_write_request *erased_p;
	203
	204	/* Look at each erased memory_write_request in turn, and
	205	see what part of it is subsequently written to.
	206
	207	This implementation is O(length(erased) * length(written)). If
	208	the lists are sorted at this point it could be rewritten more
	209	efficiently, but the complexity is not generally worthwhile. */
	210
	211	for (i = 0;
	212	VEC_iterate (memory_write_request_s, erased_blocks, i, erased_p);
	213	++i)
	214	{
	215	/* Make a deep copy -- it will be modified inside the loop, but
	216	we don't want to modify original vector. */
	217	struct memory_write_request erased = *erased_p;
	218
	219	for (j = 0; j != je;)
	220	{
	221	struct memory_write_request *written
	222	= VEC_index (memory_write_request_s,
	223	written_blocks, j);
	224
	225	/* Now try various cases. */
	226
	227	/* If WRITTEN is fully to the left of ERASED, check the next
	228	written memory_write_request. */
	229	if (written->end <= erased.begin)
	230	{
	231	++j;
	232	continue;
	233	}
	234
	235	/* If WRITTEN is fully to the right of ERASED, then ERASED
	236	is not written at all. WRITTEN might affect other
	237	blocks. */
	238	if (written->begin >= erased.end)
	239	{
	240	VEC_safe_push (memory_write_request_s, result, &erased);
	241	goto next_erased;
	242	}
243
244	/* If all of ERASED is completely written, we can move on to
245	the next erased region. */
246	if (written->begin <= erased.begin
247	&& written->end >= erased.end)
248	{
249	goto next_erased;
250	}
251
252	/* If there is an unwritten part at the beginning of ERASED,
253	then we should record that part and try this inner loop
254	again for the remainder. */
255	if (written->begin > erased.begin)
256	{
257	struct memory_write_request *n =
258	VEC_safe_push (memory_write_request_s, result, NULL);
5d502164	259
a76d924d DJ	260	memset (n, 0, sizeof (struct memory_write_request));
	261	n->begin = erased.begin;
	262	n->end = written->begin;
	263	erased.begin = written->begin;
	264	continue;
	265	}
	266
	267	/* If there is an unwritten part at the end of ERASED, we
	268	forget about the part that was written to and wait to see
	269	if the next write request writes more of ERASED. We can't
	270	push it yet. */
	271	if (written->end < erased.end)
	272	{
	273	erased.begin = written->end;
	274	++j;
	275	continue;
	276	}
	277	}
	278
	279	/* If we ran out of write requests without doing anything about
	280	ERASED, then that means it's really erased. */
	281	VEC_safe_push (memory_write_request_s, result, &erased);
	282
	283	next_erased:
	284	;
	285	}
	286
	287	return result;
	288	}
	289
	290	static void
	291	cleanup_request_data (void *p)
	292	{
19ba03f4	293	VEC(memory_write_request_s) v = (VEC(memory_write_request_s) ) p;
a76d924d DJ	294	struct memory_write_request *r;
	295	int i;
	296
	297	for (i = 0; VEC_iterate (memory_write_request_s, *v, i, r); ++i)
	298	xfree (r->data);
	299	}
	300
	301	static void
	302	cleanup_write_requests_vector (void *p)
	303	{
19ba03f4	304	VEC(memory_write_request_s) v = (VEC(memory_write_request_s) ) p;
5d502164	305
a76d924d DJ	306	VEC_free (memory_write_request_s, *v);
	307	}
	308
	309	int
	310	target_write_memory_blocks (VEC(memory_write_request_s) *requests,
	311	enum flash_preserve_mode preserve_flash_p,
	312	void (progress_cb) (ULONGEST, void ))
	313	{
	314	struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
	315	VEC(memory_write_request_s) *blocks = VEC_copy (memory_write_request_s,
	316	requests);
	317	unsigned i;
	318	int err = 0;
	319	struct memory_write_request *r;
	320	VEC(memory_write_request_s) *regular = NULL;
	321	VEC(memory_write_request_s) *flash = NULL;
	322	VEC(memory_write_request_s) erased, garbled;
	323
	324	/* END == 0 would represent wraparound: a write to the very last
	325	byte of the address space. This file was not written with that
	326	possibility in mind. This is fixable, but a lot of work for a
	327	rare problem; so for now, fail noisily here instead of obscurely
	328	later. */
	329	for (i = 0; VEC_iterate (memory_write_request_s, requests, i, r); ++i)
	330	gdb_assert (r->end != 0);
	331
	332	make_cleanup (cleanup_write_requests_vector, &blocks);
	333
	334	/* Sort the blocks by their start address. */
	335	qsort (VEC_address (memory_write_request_s, blocks),
	336	VEC_length (memory_write_request_s, blocks),
	337	sizeof (struct memory_write_request), compare_block_starting_address);
	338
	339	/* Split blocks into list of regular memory blocks,
c378eb4e	340	and list of flash memory blocks. */
a76d924d DJ	341	make_cleanup (cleanup_write_requests_vector, &regular);
	342	make_cleanup (cleanup_write_requests_vector, &flash);
	343	split_regular_and_flash_blocks (blocks, &regular, &flash);
	344
	345	/* If a variable is added to forbid flash write, even during "load",
	346	it should be checked here. Similarly, if this function is used
	347	for other situations besides "load" in which writing to flash
	348	is undesirable, that should be checked here. */
	349
	350	/* Find flash blocks to erase. */
	351	erased = blocks_to_erase (flash);
	352	make_cleanup (cleanup_write_requests_vector, &erased);
	353
	354	/* Find what flash regions will be erased, and not overwritten; then
	355	either preserve or discard the old contents. */
	356	garbled = compute_garbled_blocks (erased, flash);
	357	make_cleanup (cleanup_request_data, &garbled);
	358	make_cleanup (cleanup_write_requests_vector, &garbled);
	359
	360	if (!VEC_empty (memory_write_request_s, garbled))
	361	{
	362	if (preserve_flash_p == flash_preserve)
	363	{
	364	struct memory_write_request *r;
	365
	366	/* Read in regions that must be preserved and add them to
	367	the list of blocks we read. */
	368	for (i = 0; VEC_iterate (memory_write_request_s, garbled, i, r); ++i)
	369	{
	370	gdb_assert (r->data == NULL);
224c3ddb	371	r->data = (gdb_byte *) xmalloc (r->end - r->begin);
a76d924d DJ	372	err = target_read_memory (r->begin, r->data, r->end - r->begin);
	373	if (err != 0)
	374	goto out;
	375
	376	VEC_safe_push (memory_write_request_s, flash, r);
	377	}
	378
	379	qsort (VEC_address (memory_write_request_s, flash),
	380	VEC_length (memory_write_request_s, flash),
3e43a32a MS	381	sizeof (struct memory_write_request),
3e43a32a MS	382	compare_block_starting_address);
a76d924d DJ	383	}
	384	}
	385
	386	/* We could coalesce adjacent memory blocks here, to reduce the
	387	number of write requests for small sections. However, we would
	388	have to reallocate and copy the data pointers, which could be
	389	large; large sections are more common in loadable objects than
	390	large numbers of small sections (although the reverse can be true
	391	in object files). So, we issue at least one write request per
	392	passed struct memory_write_request. The remote stub will still
	393	have the opportunity to batch flash requests. */
	394
	395	/* Write regular blocks. */
	396	for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i)
	397	{
	398	LONGEST len;
	399
c35b1492	400	len = target_write_with_progress (current_target.beneath,
a76d924d DJ	401	TARGET_OBJECT_MEMORY, NULL,
	402	r->data, r->begin, r->end - r->begin,
	403	progress_cb, r->baton);
	404	if (len < (LONGEST) (r->end - r->begin))
	405	{
	406	/* Call error? */
	407	err = -1;
	408	goto out;
	409	}
	410	}
	411
	412	if (!VEC_empty (memory_write_request_s, erased))
	413	{
	414	/* Erase all pages. */
	415	for (i = 0; VEC_iterate (memory_write_request_s, erased, i, r); ++i)
	416	target_flash_erase (r->begin, r->end - r->begin);
	417
	418	/* Write flash data. */
	419	for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i)
	420	{
	421	LONGEST len;
	422
	423	len = target_write_with_progress (&current_target,
	424	TARGET_OBJECT_FLASH, NULL,
3e43a32a MS	425	r->data, r->begin,
3e43a32a MS	426	r->end - r->begin,
a76d924d DJ	427	progress_cb, r->baton);
	428	if (len < (LONGEST) (r->end - r->begin))
	429	error (_("Error writing data to flash"));
	430	}
	431
	432	target_flash_done ();
	433	}
	434
	435	out:
	436	do_cleanups (back_to);
	437
	438	return err;
	439	}