/* Parts of target interface that deal with accessing memory and memory-like
objects.
- Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2006-2020 Free Software Foundation, Inc.
This file is part of GDB.
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_assert.h"
+#include "gdbsupport/gdb_sys_time.h"
+#include <algorithm>
-#include <stdio.h>
-#include <sys/time.h>
-
-static int
-compare_block_starting_address (const void *a, const void *b)
+static bool
+compare_block_starting_address (const memory_write_request &a_req,
+ const memory_write_request &b_req)
{
- 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;
+ return a_req.begin < b_req.begin;
}
/* Adds to RESULT all memory write requests from BLOCK that are
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,
+claim_memory (const std::vector<memory_write_request> &blocks,
+ std::vector<memory_write_request> *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)
+ for (const memory_write_request &r : blocks)
{
/* If the request doesn't overlap [BEGIN, END), skip it. We
must handle END == 0 meaning the top of memory; we don't yet
memory, but there's an assertion in
target_write_memory_blocks which checks for that. */
- if (begin >= r->end)
+ if (begin >= r.end)
continue;
- if (end != 0 && end <= r->begin)
+ if (end != 0 && end <= r.begin)
continue;
- claimed_begin = max (begin, r->begin);
+ claimed_begin = std::max (begin, r.begin);
if (end == 0)
- claimed_end = r->end;
+ claimed_end = r.end;
else
- claimed_end = min (end, r->end);
+ claimed_end = std::min (end, r.end);
- if (claimed_begin == r->begin && claimed_end == r->end)
- VEC_safe_push (memory_write_request_s, *result, r);
+ if (claimed_begin == r.begin && claimed_end == r.end)
+ result->push_back (r);
else
{
- struct memory_write_request *n =
- VEC_safe_push (memory_write_request_s, *result, NULL);
+ struct memory_write_request n = r;
+
+ n.begin = claimed_begin;
+ n.end = claimed_end;
+ n.data += claimed_begin - r.begin;
- *n = *r;
- n->begin = claimed_begin;
- n->end = claimed_end;
- n->data += claimed_begin - r->begin;
+ result->push_back (n);
}
}
}
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)
+split_regular_and_flash_blocks (const std::vector<memory_write_request> &blocks,
+ std::vector<memory_write_request> *regular_blocks,
+ std::vector<memory_write_request> *flash_blocks)
{
struct mem_region *region;
CORE_ADDR cur_address;
cur_address = 0;
while (1)
{
- VEC(memory_write_request_s) **r;
+ std::vector<memory_write_request> *r;
region = lookup_mem_region (cur_address);
r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks;
{
struct mem_region *region;
unsigned blocksize;
+ CORE_ADDR offset_in_region;
region = lookup_mem_region (address);
gdb_assert (region->attrib.mode == MEM_FLASH);
blocksize = region->attrib.blocksize;
+
+ offset_in_region = address - region->lo;
+
if (begin)
- *begin = address / blocksize * blocksize;
+ *begin = region->lo + offset_in_region / blocksize * blocksize;
if (end)
- *end = (address + blocksize - 1) / blocksize * blocksize;
+ *end = region->lo + (offset_in_region + 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)
+static std::vector<memory_write_request>
+blocks_to_erase (const std::vector<memory_write_request> &written)
{
- unsigned i;
- struct memory_write_request *ptr;
-
- VEC(memory_write_request_s) *result = NULL;
+ std::vector<memory_write_request> result;
- for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i)
+ for (const memory_write_request &request : written)
{
CORE_ADDR begin, end;
- block_boundaries (ptr->begin, &begin, 0);
- block_boundaries (ptr->end - 1, 0, &end);
+ block_boundaries (request.begin, &begin, 0);
+ block_boundaries (request.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;
- }
+ if (!result.empty () && result.back ().end >= begin)
+ result.back ().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;
- }
+ result.emplace_back (begin, end);
}
return result;
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)
+static std::vector<memory_write_request>
+compute_garbled_blocks (const std::vector<memory_write_request> &erased_blocks,
+ const std::vector<memory_write_request> &written_blocks)
{
- VEC(memory_write_request_s) *result = NULL;
+ std::vector<memory_write_request> result;
- unsigned i, j;
- unsigned je = VEC_length (memory_write_request_s, written_blocks);
- struct memory_write_request *erased_p;
+ unsigned j;
+ unsigned je = written_blocks.size ();
/* Look at each erased memory_write_request in turn, and
see what part of it is subsequently written to.
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)
+ for (const memory_write_request &erased_iter : erased_blocks)
{
/* 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;
+ struct memory_write_request erased = erased_iter;
for (j = 0; j != je;)
{
- struct memory_write_request *written
- = VEC_index (memory_write_request_s,
- written_blocks, j);
+ const memory_write_request *written = &written_blocks[j];
/* Now try various cases. */
blocks. */
if (written->begin >= erased.end)
{
- VEC_safe_push (memory_write_request_s, result, &erased);
+ result.push_back (erased);
goto next_erased;
}
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;
+ result.emplace_back (erased.begin, written->begin);
erased.begin = written->begin;
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);
+ result.push_back (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,
+target_write_memory_blocks (const std::vector<memory_write_request> &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;
+ std::vector<memory_write_request> blocks = requests;
+ std::vector<memory_write_request> regular;
+ std::vector<memory_write_request> flash;
+ std::vector<memory_write_request> 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);
+ for (const memory_write_request &iter : requests)
+ gdb_assert (iter.end != 0);
/* 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);
+ std::sort (blocks.begin (), blocks.end (), compare_block_starting_address);
/* Split blocks into list of regular memory blocks,
- and list of flash memory blocks. */
- make_cleanup (cleanup_write_requests_vector, ®ular);
- make_cleanup (cleanup_write_requests_vector, &flash);
+ and list of flash memory blocks. */
split_regular_and_flash_blocks (blocks, ®ular, &flash);
/* If a variable is added to forbid flash write, even during "load",
/* 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))
+ std::vector<gdb::unique_xmalloc_ptr<gdb_byte>> mem_holders;
+ if (!garbled.empty ())
{
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)
+ for (memory_write_request &iter : garbled)
{
- gdb_assert (r->data == NULL);
- r->data = xmalloc (r->end - r->begin);
- err = target_read_memory (r->begin, r->data, r->end - r->begin);
+ gdb_assert (iter.data == NULL);
+ gdb::unique_xmalloc_ptr<gdb_byte> holder
+ ((gdb_byte *) xmalloc (iter.end - iter.begin));
+ iter.data = holder.get ();
+ mem_holders.push_back (std::move (holder));
+ int err = target_read_memory (iter.begin, iter.data,
+ iter.end - iter.begin);
if (err != 0)
- goto out;
+ return err;
- VEC_safe_push (memory_write_request_s, flash, r);
+ flash.push_back (iter);
}
- qsort (VEC_address (memory_write_request_s, flash),
- VEC_length (memory_write_request_s, flash),
- sizeof (struct memory_write_request),
- compare_block_starting_address);
+ std::sort (flash.begin (), flash.end (),
+ compare_block_starting_address);
}
}
have the opportunity to batch flash requests. */
/* Write regular blocks. */
- for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i)
+ for (const memory_write_request &iter : regular)
{
LONGEST len;
- len = target_write_with_progress (current_target.beneath,
+ len = target_write_with_progress (current_top_target (),
TARGET_OBJECT_MEMORY, NULL,
- r->data, r->begin, r->end - r->begin,
- progress_cb, r->baton);
- if (len < (LONGEST) (r->end - r->begin))
+ iter.data, iter.begin,
+ iter.end - iter.begin,
+ progress_cb, iter.baton);
+ if (len < (LONGEST) (iter.end - iter.begin))
{
/* Call error? */
- err = -1;
- goto out;
+ return -1;
}
}
- if (!VEC_empty (memory_write_request_s, erased))
+ if (!erased.empty ())
{
/* 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);
+ for (const memory_write_request &iter : erased)
+ target_flash_erase (iter.begin, iter.end - iter.begin);
/* Write flash data. */
- for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i)
+ for (const memory_write_request &iter : flash)
{
LONGEST len;
- len = target_write_with_progress (¤t_target,
+ len = target_write_with_progress (current_top_target (),
TARGET_OBJECT_FLASH, NULL,
- r->data, r->begin,
- r->end - r->begin,
- progress_cb, r->baton);
- if (len < (LONGEST) (r->end - r->begin))
+ iter.data, iter.begin,
+ iter.end - iter.begin,
+ progress_cb, iter.baton);
+ if (len < (LONGEST) (iter.end - iter.begin))
error (_("Error writing data to flash"));
}
target_flash_done ();
}
- out:
- do_cleanups (back_to);
-
- return err;
+ return 0;
}
projects / deliverable / binutils-gdb.git / blobdiff