1 /* Parts of target interface that deal with accessing memory and memory-like
4 Copyright (C) 2006-2018 Free Software Foundation, Inc.
6 This file is part of GDB.
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
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "memory-map.h"
26 #include "gdb_sys_time.h"
30 compare_block_starting_address (const memory_write_request
&a_req
,
31 const memory_write_request
&b_req
)
33 return a_req
.begin
< b_req
.begin
;
36 /* Adds to RESULT all memory write requests from BLOCK that are
37 in [BEGIN, END) range.
39 If any memory request is only partially in the specified range,
40 that part of the memory request will be added. */
43 claim_memory (const std::vector
<memory_write_request
> &blocks
,
44 std::vector
<memory_write_request
> *result
,
48 ULONGEST claimed_begin
;
51 for (const memory_write_request
&r
: blocks
)
53 /* If the request doesn't overlap [BEGIN, END), skip it. We
54 must handle END == 0 meaning the top of memory; we don't yet
55 check for R->end == 0, which would also mean the top of
56 memory, but there's an assertion in
57 target_write_memory_blocks which checks for that. */
61 if (end
!= 0 && end
<= r
.begin
)
64 claimed_begin
= std::max (begin
, r
.begin
);
68 claimed_end
= std::min (end
, r
.end
);
70 if (claimed_begin
== r
.begin
&& claimed_end
== r
.end
)
71 result
->push_back (r
);
74 struct memory_write_request n
= r
;
76 n
.begin
= claimed_begin
;
78 n
.data
+= claimed_begin
- r
.begin
;
80 result
->push_back (n
);
85 /* Given a vector of struct memory_write_request objects in BLOCKS,
86 add memory requests for flash memory into FLASH_BLOCKS, and for
87 regular memory to REGULAR_BLOCKS. */
90 split_regular_and_flash_blocks (const std::vector
<memory_write_request
> &blocks
,
91 std::vector
<memory_write_request
> *regular_blocks
,
92 std::vector
<memory_write_request
> *flash_blocks
)
94 struct mem_region
*region
;
95 CORE_ADDR cur_address
;
97 /* This implementation runs in O(length(regions)*length(blocks)) time.
98 However, in most cases the number of blocks will be small, so this does
101 Note also that it's extremely unlikely that a memory write request
102 will span more than one memory region, however for safety we handle
108 std::vector
<memory_write_request
> *r
;
110 region
= lookup_mem_region (cur_address
);
111 r
= region
->attrib
.mode
== MEM_FLASH
? flash_blocks
: regular_blocks
;
112 cur_address
= region
->hi
;
113 claim_memory (blocks
, r
, region
->lo
, region
->hi
);
115 if (cur_address
== 0)
120 /* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN
121 to the start of the flash block containing the address. Similarly,
122 if END is non-NULL *END will be set to the address one past the end
123 of the block containing the address. */
126 block_boundaries (CORE_ADDR address
, CORE_ADDR
*begin
, CORE_ADDR
*end
)
128 struct mem_region
*region
;
130 CORE_ADDR offset_in_region
;
132 region
= lookup_mem_region (address
);
133 gdb_assert (region
->attrib
.mode
== MEM_FLASH
);
134 blocksize
= region
->attrib
.blocksize
;
136 offset_in_region
= address
- region
->lo
;
139 *begin
= region
->lo
+ offset_in_region
/ blocksize
* blocksize
;
141 *end
= region
->lo
+ (offset_in_region
+ blocksize
- 1) / blocksize
* blocksize
;
144 /* Given the list of memory requests to be WRITTEN, this function
145 returns write requests covering each group of flash blocks which must
148 static std::vector
<memory_write_request
>
149 blocks_to_erase (const std::vector
<memory_write_request
> &written
)
151 std::vector
<memory_write_request
> result
;
153 for (const memory_write_request
&request
: written
)
155 CORE_ADDR begin
, end
;
157 block_boundaries (request
.begin
, &begin
, 0);
158 block_boundaries (request
.end
- 1, 0, &end
);
160 if (!result
.empty () && result
.back ().end
>= begin
)
161 result
.back ().end
= end
;
163 result
.emplace_back (begin
, end
);
169 /* Given ERASED_BLOCKS, a list of blocks that will be erased with
170 flash erase commands, and WRITTEN_BLOCKS, the list of memory
171 addresses that will be written, compute the set of memory addresses
172 that will be erased but not rewritten (e.g. padding within a block
173 which is only partially filled by "load"). */
175 static std::vector
<memory_write_request
>
176 compute_garbled_blocks (const std::vector
<memory_write_request
> &erased_blocks
,
177 const std::vector
<memory_write_request
> &written_blocks
)
179 std::vector
<memory_write_request
> result
;
182 unsigned je
= written_blocks
.size ();
183 struct memory_write_request
*erased_p
;
185 /* Look at each erased memory_write_request in turn, and
186 see what part of it is subsequently written to.
188 This implementation is O(length(erased) * length(written)). If
189 the lists are sorted at this point it could be rewritten more
190 efficiently, but the complexity is not generally worthwhile. */
192 for (const memory_write_request
&erased_iter
: erased_blocks
)
194 /* Make a deep copy -- it will be modified inside the loop, but
195 we don't want to modify original vector. */
196 struct memory_write_request erased
= erased_iter
;
198 for (j
= 0; j
!= je
;)
200 const memory_write_request
*written
= &written_blocks
[j
];
202 /* Now try various cases. */
204 /* If WRITTEN is fully to the left of ERASED, check the next
205 written memory_write_request. */
206 if (written
->end
<= erased
.begin
)
212 /* If WRITTEN is fully to the right of ERASED, then ERASED
213 is not written at all. WRITTEN might affect other
215 if (written
->begin
>= erased
.end
)
217 result
.push_back (erased
);
221 /* If all of ERASED is completely written, we can move on to
222 the next erased region. */
223 if (written
->begin
<= erased
.begin
224 && written
->end
>= erased
.end
)
229 /* If there is an unwritten part at the beginning of ERASED,
230 then we should record that part and try this inner loop
231 again for the remainder. */
232 if (written
->begin
> erased
.begin
)
234 result
.emplace_back (erased
.begin
, written
->begin
);
235 erased
.begin
= written
->begin
;
239 /* If there is an unwritten part at the end of ERASED, we
240 forget about the part that was written to and wait to see
241 if the next write request writes more of ERASED. We can't
243 if (written
->end
< erased
.end
)
245 erased
.begin
= written
->end
;
251 /* If we ran out of write requests without doing anything about
252 ERASED, then that means it's really erased. */
253 result
.push_back (erased
);
263 target_write_memory_blocks (const std::vector
<memory_write_request
> &requests
,
264 enum flash_preserve_mode preserve_flash_p
,
265 void (*progress_cb
) (ULONGEST
, void *))
267 std::vector
<memory_write_request
> blocks
= requests
;
268 struct memory_write_request
*r
;
269 std::vector
<memory_write_request
> regular
;
270 std::vector
<memory_write_request
> flash
;
271 std::vector
<memory_write_request
> erased
, garbled
;
273 /* END == 0 would represent wraparound: a write to the very last
274 byte of the address space. This file was not written with that
275 possibility in mind. This is fixable, but a lot of work for a
276 rare problem; so for now, fail noisily here instead of obscurely
278 for (const memory_write_request
&iter
: requests
)
279 gdb_assert (iter
.end
!= 0);
281 /* Sort the blocks by their start address. */
282 std::sort (blocks
.begin (), blocks
.end (), compare_block_starting_address
);
284 /* Split blocks into list of regular memory blocks,
285 and list of flash memory blocks. */
286 split_regular_and_flash_blocks (blocks
, ®ular
, &flash
);
288 /* If a variable is added to forbid flash write, even during "load",
289 it should be checked here. Similarly, if this function is used
290 for other situations besides "load" in which writing to flash
291 is undesirable, that should be checked here. */
293 /* Find flash blocks to erase. */
294 erased
= blocks_to_erase (flash
);
296 /* Find what flash regions will be erased, and not overwritten; then
297 either preserve or discard the old contents. */
298 garbled
= compute_garbled_blocks (erased
, flash
);
300 std::vector
<gdb::unique_xmalloc_ptr
<gdb_byte
>> mem_holders
;
301 if (!garbled
.empty ())
303 if (preserve_flash_p
== flash_preserve
)
305 /* Read in regions that must be preserved and add them to
306 the list of blocks we read. */
307 for (memory_write_request
&iter
: garbled
)
309 gdb_assert (iter
.data
== NULL
);
310 gdb::unique_xmalloc_ptr
<gdb_byte
> holder
311 ((gdb_byte
*) xmalloc (iter
.end
- iter
.begin
));
312 iter
.data
= holder
.get ();
313 mem_holders
.push_back (std::move (holder
));
314 int err
= target_read_memory (iter
.begin
, iter
.data
,
315 iter
.end
- iter
.begin
);
319 flash
.push_back (iter
);
322 std::sort (flash
.begin (), flash
.end (),
323 compare_block_starting_address
);
327 /* We could coalesce adjacent memory blocks here, to reduce the
328 number of write requests for small sections. However, we would
329 have to reallocate and copy the data pointers, which could be
330 large; large sections are more common in loadable objects than
331 large numbers of small sections (although the reverse can be true
332 in object files). So, we issue at least one write request per
333 passed struct memory_write_request. The remote stub will still
334 have the opportunity to batch flash requests. */
336 /* Write regular blocks. */
337 for (const memory_write_request
&iter
: regular
)
341 len
= target_write_with_progress (current_top_target (),
342 TARGET_OBJECT_MEMORY
, NULL
,
343 iter
.data
, iter
.begin
,
344 iter
.end
- iter
.begin
,
345 progress_cb
, iter
.baton
);
346 if (len
< (LONGEST
) (iter
.end
- iter
.begin
))
353 if (!erased
.empty ())
355 /* Erase all pages. */
356 for (const memory_write_request
&iter
: erased
)
357 target_flash_erase (iter
.begin
, iter
.end
- iter
.begin
);
359 /* Write flash data. */
360 for (const memory_write_request
&iter
: flash
)
364 len
= target_write_with_progress (current_top_target (),
365 TARGET_OBJECT_FLASH
, NULL
,
366 iter
.data
, iter
.begin
,
367 iter
.end
- iter
.begin
,
368 progress_cb
, iter
.baton
);
369 if (len
< (LONGEST
) (iter
.end
- iter
.begin
))
370 error (_("Error writing data to flash"));
373 target_flash_done ();