From 55089490f79ce1ddb9610fd6abeeaf896825fb71 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Sat, 24 Feb 2018 09:55:30 -0700 Subject: Change target_write_memory_blocks to use std::vector This changes target_write_memory_blocks to use std::vector, rather than VEC. This allows the removal of some cleanups. This version incorporates the additions that Simon made. Regression tested by the buildbot. ChangeLog 2018-02-27 Simon Marchi Tom Tromey * target.h (memory_write_request_s): Remove typedef. Don't define VEC. (target_write_memory_blocks): Change argument to std::vector. (struct memory_write_request): Add constructor. * target-memory.c (compare_block_starting_address): Return bool. Change argument types. (claim_memory): Change arguments to use std::vector. (split_regular_and_flash_blocks, blocks_to_erase) (compute_garbled_blocks): Likewise. (cleanup_request_data, cleanup_write_requests_vector): Remove. (target_write_memory_blocks): Change argument to std::vector. * symfile.c (struct load_section_data): Add constructor and destructor. Use std::vector for "requests". (struct load_progress_data): Add initializers. (load_section_callback): Update. Use "new". (clear_memory_write_data): Remove. (generic_load): Update. --- gdb/target-memory.c | 231 +++++++++++++++++++--------------------------------- 1 file changed, 82 insertions(+), 149 deletions(-) (limited to 'gdb/target-memory.c') diff --git a/gdb/target-memory.c b/gdb/target-memory.c index 81faa22a609..395bf0bae92 100644 --- a/gdb/target-memory.c +++ b/gdb/target-memory.c @@ -26,20 +26,11 @@ #include "gdb_sys_time.h" #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 - = (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; + return a_req.begin < b_req.begin; } /* Adds to RESULT all memory write requests from BLOCK that are @@ -49,17 +40,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,28 +56,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 = std::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 = std::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); } } } @@ -98,9 +87,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; @@ -116,7 +105,7 @@ split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks, cur_address = 0; while (1) { - VEC(memory_write_request_s) **r; + std::vector *r; region = lookup_mem_region (cur_address); r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks; @@ -156,35 +145,22 @@ block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end) 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; @@ -196,14 +172,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); + unsigned j; + unsigned je = written_blocks.size (); struct memory_write_request *erased_p; /* Look at each erased memory_write_request in turn, and @@ -213,19 +189,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. */ @@ -242,7 +214,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; } @@ -259,12 +231,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; } @@ -283,7 +250,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: ; @@ -292,59 +259,30 @@ 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 = (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, +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; + std::vector blocks = requests; 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 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); split_regular_and_flash_blocks (blocks, ®ular, &flash); /* If a variable is added to forbid flash write, even during "load", @@ -354,37 +292,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 = (gdb_byte *) 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); } } @@ -398,47 +334,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 (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)) + 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, 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; } -- cgit v1.2.1