X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftarget-memory.c;h=08d17f9cd180f096d24b1abe955a27e6c7ae7984;hb=74375d182e992778ef8701278c02a742db6be77e;hp=f77451a5e83be8a2e959ffcc0116e28d495153ad;hpb=0fb0cc7590113e9b459dfcc48dc71c9d419d9580;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/target-memory.c b/gdb/target-memory.c
index f77451a5e8..08d17f9cd1 100644
--- a/gdb/target-memory.c
+++ b/gdb/target-memory.c
@@ -1,7 +1,7 @@
/* Parts of target interface that deal with accessing memory and memory-like
objects.
- Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2006-2020 Free Software Foundation, Inc.
This file is part of GDB.
@@ -19,27 +19,17 @@
along with this program. If not, see . */
#include "defs.h"
-#include "vec.h"
#include "target.h"
#include "memory-map.h"
-#include "gdb_assert.h"
+#include "gdbsupport/gdb_sys_time.h"
+#include
-#include
-#include
-
-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
@@ -49,17 +39,15 @@ compare_block_starting_address (const void *a, const void *b)
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 &blocks,
+ std::vector *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
@@ -67,27 +55,28 @@ claim_memory (VEC(memory_write_request_s) *blocks,
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);
- *n = *r;
- n->begin = claimed_begin;
- n->end = claimed_end;
- n->data += claimed_begin - r->begin;
+ struct memory_write_request n = r;
+
+ n.begin = claimed_begin;
+ n.end = claimed_end;
+ n.data += claimed_begin - r.begin;
+
+ result->push_back (n);
}
}
}
@@ -97,9 +86,9 @@ claim_memory (VEC(memory_write_request_s) *blocks,
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 &blocks,
+ std::vector *regular_blocks,
+ std::vector *flash_blocks)
{
struct mem_region *region;
CORE_ADDR cur_address;
@@ -115,9 +104,9 @@ split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks,
cur_address = 0;
while (1)
{
- VEC(memory_write_request_s) **r;
- region = lookup_mem_region (cur_address);
+ std::vector *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);
@@ -137,48 +126,40 @@ block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end)
{
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
+blocks_to_erase (const std::vector &written)
{
- unsigned i;
- struct memory_write_request *ptr;
-
- VEC(memory_write_request_s) *result = NULL;
+ std::vector 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;
@@ -190,15 +171,14 @@ blocks_to_erase (VEC(memory_write_request_s) *written)
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
+compute_garbled_blocks (const std::vector &erased_blocks,
+ const std::vector &written_blocks)
{
- VEC(memory_write_request_s) *result = NULL;
+ std::vector 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.
@@ -207,19 +187,15 @@ compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
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. */
@@ -236,7 +212,7 @@ compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
blocks. */
if (written->begin >= erased.end)
{
- VEC_safe_push (memory_write_request_s, result, &erased);
+ result.push_back (erased);
goto next_erased;
}
@@ -253,11 +229,7 @@ compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
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;
}
@@ -276,7 +248,7 @@ compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
/* 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:
;
@@ -285,58 +257,29 @@ compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
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 &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 blocks = requests;
+ std::vector regular;
+ std::vector flash;
+ std::vector 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",
@@ -346,36 +289,35 @@ target_write_memory_blocks (VEC(memory_write_request_s) *requests,
/* 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> 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 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);
}
}
@@ -389,46 +331,44 @@ target_write_memory_blocks (VEC(memory_write_request_s) *requests,
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 (¤t_target,
+ 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;
}